@rentman/rm-core 1.0.0

package/src/classes/CollectionEntryService.ts

@@ -0,0 +1,83 @@
+import QueryParserFactory from "../factories/QueryParserFactory";
+import ItemEntry from "../models/ItemEntry";
+import QueryService from './QueryService';
+import { shallowMerge } from "./Util";
+
+export default class CollectionEntryService {
+	constructor (
+		private queryParserFactory: QueryParserFactory,
+		private queryService: QueryService
+	) {
+
+	}
+
+	processOptions (options) {
+		return shallowMerge(
+			options,
+			{
+				columns: [],
+				query: null,
+				queryItemType: null,
+				queryParams: {},
+				parent: null,
+				deferRequest: false,
+				limit: null,
+				entryKey: '',
+				addLocalItems: false
+			}
+		);
+	}
+
+	createQuery (options) {
+		const parent = options.parent;
+
+		let query;
+
+		if (parent === null)
+			query = options.query;
+		else {
+			const linkedToQuery = {linkedTo: parent.itemType, query: {id: '&parentId'}};
+			options.queryParams.parentId = parent.itemId;
+
+			query = options.query === null ?
+				linkedToQuery :
+				this.queryService.addAndCondition(options.query, linkedToQuery);
+		}
+
+		const parsedQuery = this.queryParserFactory.construct(query, options.queryParams).parse();
+
+		return {object: parsedQuery[0], string: parsedQuery[1]};
+	}
+
+	getIdArray (itemEntries: ItemEntry[], accumulator) {
+		if (accumulator === undefined)
+			accumulator = [];
+
+		for (const itemEntry of itemEntries)
+			accumulator.push(itemEntry.itemId);
+
+		return accumulator;
+	}
+
+	filterArray (itemEntries: ItemEntry[], callback) {
+		const filteredEntries = [];
+		const removedEntries = [];
+
+		for (const itemEntry of itemEntries) {
+			if (callback(itemEntry))
+				filteredEntries.push(itemEntry);
+			else
+				removedEntries.push(itemEntry);
+		}
+
+		if (removedEntries.length === 0)
+			return removedEntries;
+
+		itemEntries.length = filteredEntries.length;
+
+		for (let i = 0; i < itemEntries.length; i++)
+			itemEntries[i] = filteredEntries[i];
+
+		return removedEntries;
+	}
+}

package/src/classes/CollectionHandler.ts

@@ -0,0 +1,619 @@
+import { ENTRY_STATUS } from "../constants";
+import CollectionCacheFactory from "../factories/CollectionCacheFactory";
+import CollectionEntryFactory from "../factories/CollectionEntryFactory";
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import QueryParserFactory from "../factories/QueryParserFactory";
+import { identity } from "../index";
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import CollectionResource from "../models/CollectionResource";
+import ItemEntry from "../models/ItemEntry";
+import ItemResource from "../models/ItemResource";
+import CollectionCache from "./CollectionCache";
+import CollectionEntryService from "./CollectionEntryService";
+import ColumnHandler from "./ColumnHandler";
+import ColumnUtil from "./ColumnUtil";
+import ItemCache from "./ItemCache";
+import ItemEntryService from "./ItemEntryService";
+import ItemHandler from "./ItemHandler";
+import ItemRequestService from "./ItemRequestService";
+import KeyService from "./KeyService";
+import PromiseService from "./PromiseService";
+import QueryService from "./QueryService";
+import { hasProperties } from "./Util";
+
+export default class CollectionHandler {
+	entries: CollectionCache;
+
+	constructor (
+		private errorHandler: ErrorHandlerInterface,
+		private itemRequestService: ItemRequestService,
+		private itemHandler: ItemHandler,
+		private columnHandler: ColumnHandler,
+		private collectionEntryFactory: CollectionEntryFactory,
+		private collectionCacheFactory: CollectionCacheFactory,
+		private queryParserFactory: QueryParserFactory,
+		private collectionEntryService: CollectionEntryService,
+		private columnSetFactory: ColumnSetFactory,
+		private itemEntryService: ItemEntryService,
+		private keyService: KeyService,
+		private promiseService: PromiseService,
+		private queryService: QueryService,
+		private columnUtil: ColumnUtil
+	) {
+		this.entries = this.collectionCacheFactory.construct();
+	}
+
+	getPromises (statusResource) {
+		const promised = statusResource[ENTRY_STATUS.PROMISED];
+		const promisedExpand = statusResource[ENTRY_STATUS.PROMISED_EXPAND];
+		const result = [];
+
+		for (const parentId in promised)
+			result.push(promised[parentId]);
+
+		for (const parentId in promisedExpand)
+			result.push(promisedExpand[parentId]);
+
+		return result;
+	}
+
+	getRequestIds (statusResource) {
+		const result = [];
+
+		for (const parentId in statusResource[ENTRY_STATUS.RESOLVE])
+			result.push(parentId);
+
+		for (const parentId in statusResource[ENTRY_STATUS.EXPAND])
+			result.push(parentId);
+
+		return result;
+	}
+
+	removeFromAndAddToCollections (collectionMap, updateInitial?) {
+		for (const collectionId in collectionMap) {
+			const entry = collectionMap[collectionId];
+			const collection: CollectionEntry = entry.collection;
+
+			collection.removeItems(entry.notfitting, null, true);
+			collection.addItems(entry.fitting, null, true); // doesn't do anything with initial
+
+			if (entry.maybe.length > 0)
+				collection.extend(identity, null, true, updateInitial);
+		}
+	}
+
+	removeFromCollections (collectionMap, updateInitial?, resultResource: CollectionResource | null = null) {
+		let result;
+
+		for (const collectionId in collectionMap) {
+			const mapEntry = collectionMap[collectionId];
+			const fitting = mapEntry.fitting;
+			const maybe = mapEntry.maybe;
+			const collectionEntry: CollectionEntry = mapEntry.collection;
+			const idArray = [];
+
+			for (const fittingItem of fitting)
+				idArray.push(fittingItem.itemId);
+
+			for (const maybeItem of maybe)
+				idArray.push(maybeItem);
+
+			if (resultResource !== null && collectionEntry === resultResource.entry)
+				result = collectionEntry.removeItems(idArray, resultResource, updateInitial);
+			else
+				collectionEntry.removeItems(idArray, null, updateInitial);
+		}
+
+		return result;
+	}
+
+	/**
+	 * @deprecated
+	 */
+	addItemsToCollections (itemEntries: ItemEntry[]) {
+		return this.addToCollections(this.createCollectionMap(itemEntries), false);
+	}
+
+	// TODO: maybe, boolean instead of message
+	addToCollections (collectionMap, updateInitial: boolean, resultResource: ItemResource | null = null) {
+		let result;
+
+		for (const collectionId in collectionMap) {
+			const mapEntry = collectionMap[collectionId];
+			const collectionEntry = mapEntry.collection;
+
+			if (collectionEntry.isDeferred())
+				continue;
+
+			if (resultResource !== null && collectionEntry === resultResource.entry)
+				result = collectionEntry.addItems(mapEntry.fitting, resultResource, updateInitial);
+			else
+				collectionEntry.addItems(mapEntry.fitting, null, updateInitial);
+
+			if (updateInitial && mapEntry.maybe.length > 0)
+				collectionEntry.extend(identity, null, true, updateInitial);
+		}
+
+		return result;
+	}
+
+	batchExpand (parentType: string, itemType: string, collections: CollectionResource[], newColumns) {
+		if (newColumns.length === 0)
+			return this.promiseService.when(collections);
+
+		const parentIdArray = [];
+		let itemEntries = [];
+
+		// TODO: filter local items?
+
+		for (const parentId in collections) {
+			parentIdArray.push(parentId);
+
+			itemEntries = itemEntries.concat(collections[parentId].entry.items);
+		}
+
+		return this.itemRequestService.requestLinkItems(
+			parentType,
+			parentIdArray,
+			itemType,
+			null,
+			newColumns
+		).then(
+			response => {
+				const columnExpansion = this.itemRequestService.processExpansion(
+					newColumns,
+					response,
+					itemType,
+					itemEntries
+				);
+
+				for (const parentId of parentIdArray)
+					collections[parentId].entry.updateColumns(columnExpansion);
+			}
+		);
+	}
+
+	batchExtend (parentType: string, itemType: string, options, queryCallback, collections: CollectionResource[], returnAllItems = false) {
+		if (!hasProperties(collections))
+			return {};
+
+		const parentIdArray = [];
+		let itemIdArray = [];
+
+		options.queryParams = queryCallback(options.queryParams);
+
+		for (const parentId in collections) {
+			const collectionEntry = collections[parentId].entry;
+
+			collectionEntry.extendQuery(queryCallback);
+			parentIdArray.push(parentId);
+
+			itemIdArray = itemIdArray.concat(collectionEntry.getIdArray());
+		}
+
+		return this.itemRequestService.requestLinkItems(
+			parentType,
+			parentIdArray,
+			itemType,
+			this.queryService.addAndCondition(
+				this.collectionEntryService.createQuery(options).object,
+				this.queryService.createNotIn(itemIdArray)
+			),
+			options.columns
+		).then(
+			response => {
+				return this.itemRequestService.processLinkResponse(
+					response,
+					parentType,
+					parentIdArray,
+					itemType,
+					options
+				);
+			},
+			this.errorHandler.reject
+		).then(
+			itemEntryResource => {
+				const result = {};
+
+				for (const parentId of parentIdArray) {
+					const collectionResource = collections[parentId];
+					const itemResources = collectionResource.entry.addItems( // should go first
+						itemEntryResource.items[parentId],
+						collectionResource
+					);
+
+					result[parentId] = returnAllItems ? collectionResource.items : itemResources;
+				}
+
+				return result;
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	batchFetch (
+		parentType: string,
+		parentIdArray: number[],
+		itemType: string,
+		options,
+		deferredCollectionCache: CollectionCache
+	) {
+		const resource = this.createStatusResource(parentType, parentIdArray, itemType, options, deferredCollectionCache);
+
+		return this.promiseService.all(this.getPromises(resource)).then(
+			() => {
+				const requestIds = this.getRequestIds(resource);
+
+				if (requestIds.length > 0) {
+					return this.itemRequestService.requestLinkItems(
+						parentType,
+						requestIds,
+						itemType,
+						options.query === null ?
+							null :
+							this.queryParserFactory.construct(options.query, options.queryParams).parse()[0],
+						options.columns
+					).then(
+						response => {
+							return this.itemRequestService.processLinkResponse(
+								response,
+								parentType,
+								requestIds,
+								itemType,
+								options
+							);
+						},
+						this.errorHandler.reject
+					).then(
+						itemEntryResource => {
+							return this.handleBatchResponse(resource, itemEntryResource);
+						},
+						this.errorHandler.reject
+					);
+				}
+
+				if (hasProperties(resource[ENTRY_STATUS.LOCAL])) {
+					return this.columnHandler.fetch(itemType, options.columns).then(
+						responseColumns => {
+							return this.handleBatchResponse(
+								resource,
+								{
+									columns: this.columnSetFactory.construct(
+										itemType,
+										options.columns,
+										responseColumns,
+										false
+									)
+								}
+							);
+						},
+						this.errorHandler.reject
+					);
+				}
+
+				return resource[ENTRY_STATUS.CACHED];
+
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	clone (collectionEntry: CollectionEntry, options, conversionMap = {}) {
+		const itemType = collectionEntry.itemType;
+		const items = collectionEntry.items;
+		const clonedItems = [];
+
+		if (conversionMap[itemType] === undefined)
+			conversionMap[itemType] = {};
+
+		const conversionMapEntry = conversionMap[itemType];
+
+		// update the conversion map first (dependencies)
+		for (const item of items)
+			conversionMapEntry[item.itemId] = this.keyService.getLocalId();
+
+		for (const itemEntry of items) {
+			const clonedEntry = this.itemHandler.cloneItem(
+				conversionMapEntry[itemEntry.itemId],
+				itemEntry,
+				conversionMap
+			);
+
+			if (options.parent !== null)
+				clonedEntry.parent = options.parent;
+
+			clonedItems.push(clonedEntry);
+		}
+
+		return this.create(itemType, options, collectionEntry.columns, clonedItems);
+	}
+
+	create (itemType: string, options, columns, items: ItemEntry[]) {
+		return this.entries.add(
+			this.collectionEntryFactory.construct(
+				itemType,
+				options
+			)
+		).resolve(
+			{
+				columns: columns,
+				items: items
+			}
+		);
+	}
+
+	createCollectionMap (itemEntries: ItemEntry[]) {
+		const result = {};
+
+		for (const itemEntry of itemEntries)
+			this.expandCollectionMap(itemEntry, result);
+
+		return result;
+	}
+
+	createStatusResource (
+		parentType: string,
+		parentIdArray: number[],
+		itemType: string, options,
+		deferredCollectionCache: CollectionCache
+	) {
+		const result = {};
+
+		for (const statusId in ENTRY_STATUS)
+			result[ENTRY_STATUS[statusId]] = {};
+
+		for (const parentId of parentIdArray) {
+			const entryOptions = this.collectionEntryService.processOptions(options); // use processEntryOptions to clone
+
+			let statusResource;
+
+			entryOptions.parent = {itemType: parentType, itemId: parentId};
+
+			statusResource = this.getEntryStatus(itemType, entryOptions, deferredCollectionCache);
+
+			result[statusResource.status][parentId] = statusResource.entry;
+		}
+
+		return result;
+	}
+
+	expandCollectionMap (
+		itemEntry: ItemEntry,
+		accumulator,
+		collectionCache: CollectionCache = this.entries
+	) {
+		// todo: parent type
+		const parent: any = itemEntry.parent !== undefined ? itemEntry.parent : {};
+
+		const collections = collectionCache.getByFittingItem(
+			parent.itemType,
+			parent.itemId,
+			itemEntry.itemType,
+			this.itemEntryService.getFields(itemEntry)
+		);
+
+		for (const status in collections) {
+			for (const collection of collections[status]) {
+				const collectionId = collection.id;
+
+				if (accumulator[collectionId] === undefined)
+					accumulator[collectionId] = {collection: collection, fitting: [], notfitting: [], maybe: []};
+
+				accumulator[collectionId][status].push(status === 'fitting' ? itemEntry : itemEntry.itemId);
+			}
+		}
+	}
+
+	fetch (itemType: string, options, itemCache: ItemCache, deferredCollectionCache: CollectionCache) {
+		const statusResource = this.getEntryStatus(itemType, options, deferredCollectionCache);
+		const entry = statusResource.entry;
+
+		switch (statusResource.status) {
+			case ENTRY_STATUS.CACHED:
+				return this.promiseService.when(entry);
+			case ENTRY_STATUS.PROMISED:
+				return entry.promise;
+			case ENTRY_STATUS.EXPAND:
+				return entry.expand(options.columns);
+			case ENTRY_STATUS.PROMISED_EXPAND:
+				return entry.promise.then(
+					() => {
+						return entry.expand(options.columns);
+					},
+					this.errorHandler.reject
+				);
+			case ENTRY_STATUS.RESOLVE:
+				return this.resolveRemote(entry, itemCache);
+			case ENTRY_STATUS.LOCAL:
+				return this.resolveLocal(entry, itemCache);
+		}
+	}
+
+	getDeferredEntryStatus (collectionEntry: CollectionEntry, options) {
+		// because the collection entry is not fully loaded yet, we'll have to rely on the options
+		const entryOptions = collectionEntry.options;
+		const entryColumns = entryOptions.columns;
+
+		let isColumnSubset = false;
+
+		if (collectionEntry.reloadQueued) {
+			collectionEntry.reloadQueued = false;
+			entryOptions.columns = this.columnUtil.mergeRequestColumns(options.columns, entryColumns).merged;
+
+			return {
+				entry: collectionEntry,
+				status: collectionEntry.isLocal() ? ENTRY_STATUS.LOCAL : ENTRY_STATUS.RESOLVE
+			};
+		}
+
+		if (entryColumns === true) {
+			console.warn('Columns: true for collections is deprecated!');
+			isColumnSubset = true;
+		} else
+			isColumnSubset = this.columnUtil.isColumnSubset(options.columns, entryColumns, false);
+
+		return {
+			entry: collectionEntry,
+			status: isColumnSubset ? ENTRY_STATUS.PROMISED : ENTRY_STATUS.PROMISED_EXPAND
+		};
+	}
+
+	getEntryStatus (itemType: string, options, deferredEntries: CollectionCache) {
+		const query = this.collectionEntryService.createQuery(options);
+		const cachedEntry = this.entries.getByQuery(itemType, query);
+
+		if (cachedEntry === null)
+			return this.getNewEntryStatus(itemType, query, options, deferredEntries);
+
+		if (cachedEntry.isDeferred())
+			return this.getDeferredEntryStatus(cachedEntry, options);
+
+		return {
+			entry: cachedEntry,
+			status: this.columnUtil.isColumnSubset(options.columns, cachedEntry.columns.request, cachedEntry.columns.true) ?
+				ENTRY_STATUS.CACHED : ENTRY_STATUS.EXPAND
+		};
+	}
+
+	getNewEntryStatus (itemType: string, query, options, deferredEntries: CollectionCache) {
+		let collectionEntry;
+		let deferredOptions;
+
+		if (options.deferRequest) {
+			collectionEntry = deferredEntries.getByQuery(itemType, query);
+
+			if (collectionEntry === null) {
+				return {
+					entry: deferredEntries.add(this.collectionEntryFactory.construct(itemType, options)),
+					status: ENTRY_STATUS.PROMISED
+				};
+			}
+
+			deferredOptions = collectionEntry.options;
+			deferredOptions.columns = this.columnUtil.mergeRequestColumns(deferredOptions.columns, options.columns).merged;
+		} else {
+			collectionEntry = this.collectionEntryFactory.construct(itemType, options);
+		}
+
+		this.entries.add(collectionEntry); // will also add the deferred entry
+
+		return {
+			entry: collectionEntry,
+			status: collectionEntry.isLocal() ? ENTRY_STATUS.LOCAL : ENTRY_STATUS.RESOLVE
+		};
+	}
+
+	handleBatchResponse (statusResource, itemEntryResource) {
+		const result = {};
+
+		for (const parentId in statusResource.cached)
+			result[parentId] = statusResource.cached[parentId];
+
+		for (const parentId in statusResource.resolve) {
+			result[parentId] = statusResource.resolve[parentId].resolve(
+				{
+					items: itemEntryResource.items[parentId],
+					columns: itemEntryResource.columns
+				}
+			);
+		}
+
+		for (const parentId in statusResource.expand) {
+			const collectionEntry: CollectionEntry = statusResource.expand[parentId];
+
+			collectionEntry.updateColumns(itemEntryResource.columnExpansion);
+
+			result[parentId] = collectionEntry;
+		}
+
+		for (const parentId in statusResource.local) {
+			const collectionEntry: CollectionEntry = statusResource.local[parentId];
+
+			result[parentId] = collectionEntry.resolve(
+				{
+					items: this.itemHandler.entries.getByParent( // TODO: use tab cache?
+						collectionEntry.parent.itemType,
+						parentId,
+						collectionEntry.itemType
+					),
+					columns: itemEntryResource.columns
+				}
+			);
+		}
+
+		return result;
+	}
+
+	/**
+	 * @deprecated
+	 */
+	removeItemsFromAndAddItemsToCollections (itemEntries: ItemEntry[]) {
+		return this.removeFromAndAddToCollections(
+			this.createCollectionMap(itemEntries),
+			false
+		);
+	}
+
+	/**
+	 * @deprecated
+	 */
+	// TODO: maybe
+	removeItemsFromCollections (itemEntries: ItemEntry[]) {
+		return this.removeFromCollections(
+			this.createCollectionMap(itemEntries),
+			false
+		);
+	}
+
+	resolveLocal (collectionEntry: CollectionEntry, itemCache) {
+		const itemType = collectionEntry.itemType;
+		const requestColumns = collectionEntry.options.columns;
+
+		return this.columnHandler.fetch(itemType, requestColumns).then(
+			responseColumns => {
+				return collectionEntry.resolve(
+					{
+						items: itemCache.getByQuery(itemType, collectionEntry.query),
+						columns: this.columnSetFactory.construct(itemType, requestColumns, responseColumns, false)
+					}
+				);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	resolveRemote (collectionEntry, itemCache) {
+		const itemType = collectionEntry.itemType;
+		const options = collectionEntry.options;
+
+		let columnInfo;
+
+		return this.itemRequestService.requestItems(collectionEntry).then(
+			response => {
+				columnInfo = this.columnSetFactory.construct(itemType, options.columns, response.fetchColumnsObject());
+
+				return this.itemRequestService.processResponse(
+					response,
+					response.links[itemType],
+					collectionEntry.parent,
+					columnInfo
+				);
+			},
+			this.errorHandler.reject
+		).then(itemEntries => {
+				return collectionEntry.resolve(
+					{
+						items: itemEntries.concat(
+							options.addLocalItems ?
+								itemCache.getLocalByQuery(itemType, collectionEntry.query) :
+								[]
+						),
+						columns: columnInfo
+					}
+				);
+			},
+			this.errorHandler.reject
+		);
+	}
+}