@rentman/rm-core 1.0.0 → 1.0.2

package/src/classes/ItemHandler.ts

@@ -1,592 +0,0 @@
-import { ENTRY_STATUS } from "../constants";
-import BatchStatusFactory from "../factories/BatchStatusFactory";
-import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
-import ColumnSetFactory from "../factories/ColumnSetFactory";
-import ItemCacheFactory from "../factories/ItemCacheFactory";
-import ItemEntryFactory from "../factories/ItemEntryFactory";
-import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
-import AuthInterface from '../interfaces/AuthInterface';
-import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
-import ItemEntry from "../models/ItemEntry";
-import ApiFormatter from "./ApiFormatter";
-import ColumnHandler from './ColumnHandler';
-import ColumnUtil from './ColumnUtil';
-import ItemCache from "./ItemCache";
-import ItemEntryService from "./ItemEntryService";
-import KeyService from "./KeyService";
-import PromiseService from "./PromiseService";
-import { getFirstProperty, hasProperties } from './Util';
-
-export default class ItemHandler {
-	entries: ItemCache;
-	templates = {};
-
-	constructor (
-		private apiRequestService: ApiRequestServiceInterface,
-		private authInterface: AuthInterface,
-		private errorHandler: ErrorHandlerInterface,
-		private itemEntryFactory: ItemEntryFactory,
-		private columnHandler: ColumnHandler,
-		private itemCacheFactory: ItemCacheFactory,
-		private batchStatusFactory: BatchStatusFactory,
-		private columnExpansionFactory: ColumnExpansionFactory,
-		private columnSetFactory: ColumnSetFactory,
-		private itemEntryService: ItemEntryService,
-		private apiFormatter: ApiFormatter,
-		private keyService: KeyService,
-		private promiseService: PromiseService,
-		private columnUtil: ColumnUtil
-	) {
-		this.entries = this.itemCacheFactory.construct();
-	}
-
-	getItemId (itemEntry: ItemEntry) {
-		return itemEntry.itemId;
-	}
-
-	getPromise (itemEntry: ItemEntry) {
-		return itemEntry.deferred.promise;
-	}
-
-	fetchItem (itemType: string, itemId: number, options: any) {
-		const entryStatus = this.getEntryStatus(itemType, itemId, options);
-		const itemEntry = entryStatus.entry;
-		const status = entryStatus.status;
-
-		if (status === ENTRY_STATUS.LOCAL) {
-			return this.fetchTemplate(itemType, options.templateOptions, options.templateColumns)
-				.then(
-					template => {
-						return this.resolveLocal(itemEntry, options.parent, template);
-					},
-					error => {
-						this.itemEntryService.reject(itemEntry, error);
-
-						return error;
-					}
-				);
-		}
-
-		return this.resolveCached(itemEntry, status, options);
-	}
-
-	fetchItems (itemType, itemIds, options) {
-		const batchStatus = this.batchStatusFactory.construct(
-			(itemEntry: ItemEntry) => this.getItemId(itemEntry),
-			(itemEntry: ItemEntry) => this.getPromise(itemEntry)
-		);
-
-		const promises: any = {};
-
-		for (const itemId of itemIds)
-			batchStatus.add(this.getEntryStatus(itemType, itemId, options));
-
-		promises.entries = batchStatus.getPromises();
-
-		if (batchStatus.hasRequests())
-			promises.requests = this.requestItem(itemType, batchStatus.getRequestIds(), options.columns);
-
-		if (batchStatus.hasEntries([ENTRY_STATUS.LOCAL]))
-			promises.template = this.fetchTemplate(itemType, options.templateOptions, options.templateColumns);
-
-		return this.promiseService.all(promises).then(resolved => {
-				return this.batchResolve(itemType, batchStatus, options.columns, resolved);
-			},
-			this.errorHandler.reject
-		);
-	}
-
-	resolveCached (itemEntry: ItemEntry, status, options) {
-		const itemType = itemEntry.itemType;
-		const itemId = itemEntry.itemId;
-		const requestColumns = itemEntry.columns.request;
-
-		switch (status) {
-			case ENTRY_STATUS.CACHED:
-				return this.promiseService.when(itemEntry);
-			case ENTRY_STATUS.PROMISED:
-				return itemEntry.deferred.promise;
-			case ENTRY_STATUS.PROMISED_EXPAND:
-				return itemEntry.deferred.promise.then(
-					() => {
-						return this.resolveCached(
-							itemEntry,
-							this.getCachedEntryStatus(itemEntry, options),
-							options
-						);
-					},
-					this.errorHandler.reject
-				);
-		}
-
-		if (status === ENTRY_STATUS.EXPAND) {
-			const columnDifference = this.columnUtil.mergeRequestColumns(requestColumns, options.columns).difference;
-
-			this.requestItem(itemType, itemId, columnDifference).then(
-				response => {
-					this.resolveExpansion(
-						itemEntry,
-						this.columnExpansionFactory.construct(itemType, columnDifference, response.fetchColumnsObject()),
-						response
-					);
-				},
-				error => {
-					this.itemEntryService.reject(itemEntry, error);
-				}
-			);
-		} else {
-			this.requestItem(itemType, itemId, requestColumns).then(
-				response => {
-					this.resolveRemote(
-						itemEntry,
-						this.columnSetFactory.construct(itemType, requestColumns, response.fetchColumnsObject()),
-						response
-					);
-				},
-				error => {
-					this.itemEntryService.reject(itemEntry, error);
-				}
-			);
-		}
-
-		return itemEntry.deferred.promise;
-	}
-
-	resolveLocal (itemEntry: ItemEntry, parent, template) {
-		const itemType = itemEntry.itemType;
-		const itemId = itemEntry.itemId;
-		const conversionMap = this.createConversionMap(itemType, itemId, true, template.response);
-
-		itemEntry.columns = template.columns;
-
-		if (parent !== null)
-			this.itemEntryService.setParent(itemEntry, parent.itemType, parent.itemId); // create new object
-
-		this.itemEntryService.processLocal(
-			itemEntry,
-			template.fields,
-			{},
-			{},
-			conversionMap
-		);
-
-		this.setCreator(itemEntry);
-
-		this.itemEntryService.resolve(itemEntry);
-
-		return {
-			main: itemEntry,
-			linked: this.createLocalEntries(itemType, itemId, template, conversionMap)
-		};
-	}
-
-	resolveExpansion (itemEntry, columnExpansion, response) {
-		const itemType = itemEntry.itemType;
-		const itemId = itemEntry.itemId;
-		const expansionResult = columnExpansion(itemEntry.columns, true);
-
-		// Another request already requested the columns we need here, no need to expand the item and resolve it (already done by other request)
-		if (expansionResult === null)
-			return itemEntry;
-
-		this.itemEntryService.expand(
-			itemEntry,
-			response.fetchObject(itemType, itemId),
-			response.fetchDerivedObject(itemType, itemId, expansionResult.difference.root),
-			expansionResult
-		);
-
-		return this.itemEntryService.resolve(itemEntry);
-	}
-
-	resolveRemote (itemEntry, columnInfo, response) {
-		const itemType = itemEntry.itemType;
-		const itemId = itemEntry.itemId;
-		const initial = response.fetchObject(itemType, itemId);
-
-		if (initial === undefined) { // query returned no results
-			this.itemEntryService.reject(itemEntry);
-			this.entries.clear(itemEntry);
-
-			return null;
-		}
-
-		return this.resolveDeferredEntry(
-			itemEntry,
-			initial,
-			response.fetchDerivedObject(itemType, itemId, columnInfo.root),
-			columnInfo
-		);
-	}
-
-	fetchTemplate (itemType: string, templateOptions: any = {}, templateColumns: any = {}): Promise<any> {
-		const hasTemplateOptions = hasProperties(templateOptions);
-		const columnItemType = getFirstProperty(templateColumns); // it's possible to add columns to linked items
-
-		if (!hasTemplateOptions) {
-			const cachedTemplate = this.templates[itemType];
-
-			if (
-				cachedTemplate !== undefined &&
-				(
-					columnItemType === null ||
-					this.columnUtil.responseColumnsAvailable(
-						columnItemType,
-						templateColumns[columnItemType],
-						cachedTemplate.responseColumns
-					)
-				)
-			) {
-				return this.promiseService.when(cachedTemplate);
-			}
-		}
-
-		return this.promiseService.all([
-			this.apiRequestService.template(itemType, templateOptions),
-			columnItemType === null ?
-				{} :
-				this.columnHandler.fetch(columnItemType, templateColumns[columnItemType])
-		]).then(
-			resolved => {
-				const templateResponse: any = resolved[0];
-				const responseColumns = this.columnUtil.mergeResponseColumns(
-					templateResponse.fetchColumnsObject(),
-					resolved[1]
-				).merged;
-				const template = {
-					fields: templateResponse.fetchObject(
-						itemType,
-						templateResponse.links[itemType][0]
-					),
-					columns: this.columnSetFactory.construct(itemType, true, responseColumns),
-					response: templateResponse,
-					responseColumns: responseColumns
-				};
-
-				if (!hasTemplateOptions && templateResponse.cacheable)
-					this.templates[itemType] = template;
-
-				return template;
-			},
-			this.errorHandler.reject
-		);
-	}
-
-	getEntryStatus (itemType: string, itemId: number, options: any) {
-		const cachedEntry: ItemEntry = this.entries.get(itemType, itemId);
-
-		if (cachedEntry === undefined) {
-			if (this.keyService.isLocalId(itemId)) {
-				return {
-					entry: this.createDeferredEntry(itemType, itemId, true, false),
-					status: ENTRY_STATUS.LOCAL
-				};
-			}
-
-			return {
-				entry: this.createDeferredEntry(itemType, itemId, options.columns, options.deferRequest),
-				status: options.deferRequest ? ENTRY_STATUS.PROMISED : ENTRY_STATUS.RESOLVE
-			};
-		}
-
-		return {entry: cachedEntry, status: this.getCachedEntryStatus(cachedEntry, options)};
-	}
-
-	getCachedEntryStatus (itemEntry: ItemEntry, options) {
-		const columns = itemEntry.columns;
-		const isColumnSubset = this.itemEntryService.isLocal(itemEntry) ||
-			this.columnUtil.isColumnSubset(options.columns, columns.request, columns.true);
-
-		if (itemEntry.deferred !== undefined) {
-			if (itemEntry.deferRequest) {
-				columns.request = this.columnUtil.mergeRequestColumns(columns.request, options.columns).merged;
-
-				return ENTRY_STATUS.RESOLVE;
-			}
-
-			return isColumnSubset ? ENTRY_STATUS.PROMISED : ENTRY_STATUS.PROMISED_EXPAND;
-		}
-
-		if (isColumnSubset)
-			return ENTRY_STATUS.CACHED;
-
-		this.itemEntryService.defer(itemEntry, false);
-
-		return ENTRY_STATUS.EXPAND;
-	}
-
-	createDeferredEntry (itemType: string, itemId: number, requestColumns, deferRequest) {
-		const itemEntry = this.createEntryStub(itemType, itemId);
-
-		itemEntry.columns = {
-			itemType: itemType,
-			request: requestColumns,
-			true: requestColumns === true
-		};
-
-		return this.itemEntryService.defer(itemEntry, deferRequest);
-	}
-
-	createEntryStub (itemType: string, itemId: number) {
-		return this.entries.add(
-			this.itemEntryFactory.construct(
-				itemType,
-				itemId
-			)
-		);
-	}
-
-	createEntry (itemId: number, initial, derived, columnInfo) {
-		return this.itemEntryService.process(
-			this.entries.add(
-				this.itemEntryFactory.construct(
-					columnInfo.itemType,
-					itemId,
-					columnInfo,
-					initial,
-					derived
-				)
-			)
-		);
-	}
-
-	resolveDeferredEntry (itemEntry, initial, derived, columns) {
-		itemEntry.columns = columns;
-		itemEntry.initial = initial;
-		itemEntry.derived = derived;
-
-		this.itemEntryService.process(itemEntry);
-
-		return this.itemEntryService.resolve(itemEntry);
-	}
-
-	batchResolve (itemType, batchStatus, requestColumns, resolved) {
-		const response = resolved.requests;
-		const expandStatus = [ENTRY_STATUS.EXPAND, ENTRY_STATUS.PROMISED_EXPAND];
-		const resolveStatus = [ENTRY_STATUS.RESOLVE];
-
-		let success = true;
-
-		if (batchStatus.hasEntries(expandStatus)) {
-			const columnExpansion = this.columnExpansionFactory.construct(itemType, requestColumns, response.fetchColumnsObject());
-
-			batchStatus.forEachEntry(
-				expandStatus, itemEntry => {
-					this.resolveExpansion(itemEntry, columnExpansion, response);
-				}
-			);
-		}
-
-		if (batchStatus.hasEntries(resolveStatus)) {
-			const columnInfo = this.columnSetFactory.construct(itemType, requestColumns, response.fetchColumnsObject());
-
-			batchStatus.forEachEntry(
-				resolveStatus, itemEntry => {
-					if (this.resolveRemote(itemEntry, columnInfo, response) === null)
-						success = false;
-				}
-			);
-		}
-
-		batchStatus.forEachEntry(
-			[ENTRY_STATUS.LOCAL], itemEntry => {
-				this.resolveLocal(itemEntry, null, resolved.template);
-			}
-		);
-
-		return success ? batchStatus.getArray() : this.errorHandler.reject({message: this.itemEntryService.undefinedItemError});
-	}
-
-	cloneItem (newItemId, itemEntry, conversionMap?) {
-		const columns = itemEntry.columns;
-		const parent = itemEntry.parent;
-
-		if (conversionMap === undefined) {
-			conversionMap = {
-				[itemEntry.itemType]: {
-					[itemEntry.itemId]: newItemId
-				}
-			};
-		}
-
-		// we'll copy modified to result.initial (initial may be a template)
-		const result = this.createEntry(
-			newItemId,
-			this.apiFormatter.copyFields(this.itemEntryService.getFields(itemEntry), {}, columns.main),
-			this.apiFormatter.copyFields(itemEntry.derived, {}, columns.derived),
-			columns
-		);
-
-		this.itemEntryService.updateItemFields(result, conversionMap);
-
-		result.modified = this.apiFormatter.copyFields(result.initial, {}, columns.main);
-
-		if (!parent)
-			return result;
-
-		return this.itemEntryService.setParent(result, parent.itemType, parent.itemId);
-	}
-
-	createConversionMap (itemType: string, itemId: number, extend: boolean, response) {
-		const apiItemId = response.links[itemType][0];
-		const result = {
-			[itemType]: {
-				[apiItemId]: itemId
-			}
-		};
-
-		if (extend)
-			this.extendConversionMap(
-				result,
-				response.items[itemType][apiItemId].links,
-				response
-			);
-
-		return result;
-	}
-
-	createLocalEntries (parentType: string, localParentId: number, template, conversionMap) {
-		const self = this;
-		const apiResponse = template.response;
-		const columnInfoMap = {};
-		const itemEntryMap = {};
-		const result = [];
-
-		// TODO: disable caching?
-		for (const itemType in apiResponse.items) {
-			if (itemType === parentType)
-				continue;
-
-			columnInfoMap[itemType] = this.columnSetFactory.construct(
-				itemType,
-				true,
-				template.responseColumns
-			);
-		}
-
-		const createEntries = (parentType2, localParentId2, apiParentId) => {
-			const parent = {itemType: parentType2, itemId: localParentId2};
-			const links = apiResponse.items[parentType2][apiParentId].links;
-
-			for (const itemType in links) {
-				const idArray = links[itemType];
-
-				// the item entries should be added to the result in top-down order
-				if (itemEntryMap[itemType] === undefined)
-					result.push({itemType: itemType, itemEntries: itemEntryMap[itemType] = []});
-
-				for (const apiItemId of idArray) {
-					const localItemId = conversionMap[itemType][apiItemId];
-					const itemEntry = self.createEntryStub(itemType, localItemId);
-
-					itemEntry.columns = columnInfoMap[itemType];
-					itemEntry.parent = parent;
-
-					this.itemEntryService.processLocal(
-						itemEntry,
-						apiResponse.fetchObject(itemType, apiItemId),
-						{},
-						{},
-						conversionMap
-					);
-
-					this.setCreator(itemEntry);
-
-					itemEntryMap[itemType].push(itemEntry);
-
-					createEntries(itemType, localItemId, apiItemId);
-				}
-			}
-		};
-
-		createEntries(parentType, localParentId, apiResponse.links[parentType][0]);
-
-		return result;
-	}
-
-	createLocalEntry (itemId: number, template, modified, derived, parent = null) {
-		const itemType = template.columns.itemType;
-		const itemEntry = this.createEntryStub(itemType, itemId);
-
-		itemEntry.columns = template.columns;
-
-		if (parent !== null)
-			itemEntry.parent = parent;
-
-		this.itemEntryService.processLocal(
-			itemEntry,
-			template.fields,
-			modified,
-			derived,
-			this.createConversionMap(itemType, itemId, false, template.response)
-		);
-
-		this.setCreator(itemEntry);
-
-		return itemEntry;
-	}
-
-	extendConversionMap (conversionMap, links, apiResponse) {
-		for (const itemType in links) {
-			const idArray = links[itemType];
-
-			if (conversionMap[itemType] === undefined)
-				conversionMap[itemType] = {};
-
-			for (const apiItemId of idArray) {
-				conversionMap[itemType][apiItemId] = this.keyService.getLocalId();
-
-				this.extendConversionMap(
-					conversionMap,
-					apiResponse.items[itemType][apiItemId].links,
-					apiResponse
-				);
-			}
-		}
-	}
-
-	fetchTitle (itemType: string, itemId: number, deferRequest = true) {
-		const titleField = this.itemEntryService.getTitleField(itemType);
-
-		return this.fetchItem(
-			itemType,
-			itemId,
-			this.itemEntryService.processOptions({
-				columns: [titleField],
-				deferRequest: deferRequest
-			})
-		).then(
-			(entry: ItemEntry | any) => {
-				// fetchItem can also return linked items
-				if (entry.main !== undefined)
-					return entry.main.initial[titleField];
-
-				if (entry.modified !== undefined)
-					return entry.modified[titleField];
-
-				return entry.initial[titleField];
-			},
-			this.errorHandler.reject
-		);
-	}
-
-	requestItem (itemType: string, itemId: number | number[], columns) {
-		const requestColumns = {
-			[itemType]: columns
-		};
-
-		return this.apiRequestService.query(itemType, {id: itemId}, requestColumns);
-	}
-
-	updateItemId (itemEntry, itemId) {
-		const oldItemId = itemEntry.itemId;
-		itemEntry.itemId = itemId;
-
-		return this.entries.updateItemId(itemEntry, oldItemId);
-	}
-
-	private setCreator (itemEntry: ItemEntry) {
-		itemEntry.modified.creator = this.authInterface.getUserId();
-		itemEntry.derived['creator>displayname'] = this.authInterface.getUserDisplayname();
-	}
-}