@rentman/rm-core 1.0.0

package/src/classes/ItemRequestService.ts

@@ -0,0 +1,229 @@
+import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import ItemEntry from "../models/ItemEntry";
+import ColumnExpansion from "./ColumnExpansion";
+import ColumnHandler from "./ColumnHandler";
+import ItemEntryService from "./ItemEntryService";
+import ItemHandler from "./ItemHandler";
+import PromiseService from "./PromiseService";
+import QueryService from "./QueryService";
+
+import { pathExists } from "./Util";
+
+export default class ItemRequestService {
+	constructor (
+		private apiRequestService: ApiRequestServiceInterface,
+		private errorHandler: ErrorHandlerInterface,
+		private itemHandler: ItemHandler,
+		private columnHandler: ColumnHandler,
+		private columnExpansionFactory: ColumnExpansionFactory,
+		private columnSetFactory: ColumnSetFactory,
+		private itemEntryService: ItemEntryService,
+		private queryService: QueryService,
+		private promiseService: PromiseService
+	) {
+	}
+
+	requestItem (itemType, itemId, columns) {
+		const requestColumns = {
+			[itemType]: columns
+		};
+
+		return this.apiRequestService.query(
+			itemType,
+			{id: itemId},
+			requestColumns
+		);
+	}
+
+	requestItems (collectionEntry: CollectionEntry, query = collectionEntry.query.object, columns = collectionEntry.options.columns) {
+		const options = collectionEntry.options;
+
+		const requestColumns = {
+			[collectionEntry.itemType]: columns
+		};
+
+		const params = {
+			requestType: 'query',
+			columns: requestColumns,
+			query: query,
+			itemType: '',
+			allLinkIds: false,
+			limit: null
+		};
+
+		if (options.queryItemType === null)
+			params.itemType = collectionEntry.itemType;
+		else {
+			params.itemType = options.queryItemType;
+			params.allLinkIds = true;
+		}
+
+		if (options.limit !== null)
+			params.limit = options.limit;
+
+		return this.apiRequestService.requestSkeleton(params);
+	}
+
+	requestLinkItems (parentType, parentIdArray, itemType, query, columns): Promise<any> {
+		const requestColumns = {
+			[itemType]: columns
+		};
+
+		return query === null ?
+			this.apiRequestService.query(
+				parentType,
+				{id: parentIdArray},
+				requestColumns
+			) :
+			this.apiRequestService.query(
+				itemType,
+				this.queryService.addAndCondition(
+					query,
+					{linkedTo: parentType, query: {id: parentIdArray}}
+				),
+				requestColumns // should contain a derived column that refers to the parent
+			);
+	}
+
+	processExpansion (requestColumns, response, itemType: string, itemEntries: ItemEntry[]) {
+		const columnExpansion = this.columnExpansionFactory.construct(
+			itemType,
+			requestColumns,
+			response.fetchColumnsObject()
+		);
+
+		for (const itemEntry of itemEntries) {
+			if (this.itemEntryService.isLocal(itemEntry))
+				continue;
+
+			this.handleCachedItem(
+				itemEntry,
+				response,
+				columnExpansion
+			);
+		}
+
+		return columnExpansion;
+	}
+
+	processResponse (response, idArray, parent, columnInfo, columnExpansion?): Promise<ItemEntry[]> {
+		if (columnExpansion === undefined)
+			columnExpansion = this.columnExpansionFactory.construct(
+				columnInfo.itemType,
+				columnInfo.true ? true : columnInfo.request,
+				columnInfo.response
+			);
+
+		const itemType = columnInfo.itemType;
+		const rootColumns = columnInfo.root;
+		const itemEntries = [];
+		const deferredEntries = [];
+
+		// should be fast...
+		for (const itemId of idArray) {
+			let itemEntry = this.itemHandler.entries.get(itemType, itemId);
+
+			if (itemEntry === undefined) {
+				itemEntry = this.itemHandler.createEntry(
+					itemId,
+					response.fetchObject(itemType, itemId),
+					response.fetchDerivedObject(itemType, itemId, rootColumns),
+					columnInfo
+				);
+				itemEntries.push(itemEntry);
+			} else {
+				if (itemEntry.deferred !== undefined) {
+					if (itemEntry.deferRequest) {
+						itemEntries.push(
+							this.itemHandler.resolveDeferredEntry(
+								itemEntry,
+								response.fetchObject(itemType, itemId),
+								response.fetchDerivedObject(itemType, itemId, rootColumns),
+								columnInfo
+							)
+						);
+					} else
+						deferredEntries.push(itemEntry.deferred.promise);
+				} else {
+					itemEntries.push(
+						this.handleCachedItem(
+							itemEntry,
+							response,
+							columnExpansion
+						)
+					);
+				}
+			}
+
+			if (parent !== null)
+				itemEntry.parent = parent;
+		}
+
+		return this.promiseService.all(deferredEntries).then(
+			resolvedEntries => {
+				for (const resolvedEntry of resolvedEntries)
+					itemEntries.push(
+						this.handleCachedItem(
+							resolvedEntry,
+							response,
+							columnExpansion
+						)
+					);
+
+				return itemEntries;
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	handleCachedItem (itemEntry, response, columnExpansion: ColumnExpansion) {
+		const expansionResult = columnExpansion.run(itemEntry.columns, true);
+
+		return expansionResult === null ?
+			itemEntry :
+			this.itemEntryService.expand(
+				itemEntry,
+				response.fetchObject(itemEntry.itemType, itemEntry.itemId),
+				response.fetchDerivedObject(
+					itemEntry.itemType,
+					itemEntry.itemId,
+					expansionResult.difference.root
+				),
+				expansionResult
+			);
+	}
+
+	processLinkResponse (response, parentType, parentIdArray, itemType, options) {
+		const responseColumns = response.fetchColumnsObject();
+		const columnInfo = this.columnSetFactory.construct(itemType, options.columns, responseColumns);
+		const columnExpansion = this.columnExpansionFactory.construct(itemType, options.columns, responseColumns);
+		const parentItems = response.items[parentType];
+		const promises = {};
+
+		for (const parentId of parentIdArray) {
+			promises[parentId] = pathExists(parentItems, [parentId, 'links', itemType]) ?
+				this.processResponse(
+					response,
+					parentItems[parentId].links[itemType],
+					{itemType: parentType, itemId: parentId},
+					columnInfo,
+					columnExpansion.run
+				) :
+				[];
+		}
+
+		return this.promiseService.all(promises).then(resolved => {
+				return {
+					items: resolved,
+					columns: columnInfo,
+					columnExpansion: columnExpansion.run
+				};
+			},
+			this.errorHandler.reject
+		);
+	}
+}

package/src/classes/ItemResourceService.ts

@@ -0,0 +1,36 @@
+import { noop } from '../index';
+import ItemEntryService from "./ItemEntryService";
+import { shallowMerge } from "./Util";
+
+export default class ItemResourceService {
+	constructor (
+		private itemEntryService: ItemEntryService
+	) {
+
+	}
+
+	processOptions (options) {
+		return shallowMerge(
+			options,
+			{
+				edit: false,
+				onChange: noop,
+				onDeactivate: noop
+			}
+		);
+	}
+
+	compareOptions (first, second) {
+		for (const key in first) {
+			if (first[key] !== second[key])
+				return false;
+		}
+
+		return true;
+	}
+
+	isNew (resource) {
+		return this.itemEntryService.isLocal(resource.entry) &&
+			resource.transactions === undefined;
+	}
+}

package/src/classes/KeyService.ts

@@ -0,0 +1,76 @@
+export default class KeyService {
+	NEW_PREFIX: string = '-1';
+	DUPLICATE_PREFIX: string = '-2';
+
+	NEW_KEYWORD: string = 'new-';
+	DUPLICATE_KEYWORD: string = 'dup-';
+
+	seperator: string = ':';
+
+	constructor () {
+	}
+
+	getSingleKey (itemType: string, itemId: number | string) {
+		return itemType.concat(this.seperator, String(itemId));
+	}
+
+	getCollectionCacheKey (parentType: string, parentId: number, childType: string) {
+		return parentType.concat(this.seperator, String(parentId), this.seperator, childType);
+	}
+
+	getCssKey () {
+		return Array.prototype.join.call(arguments, '_');
+	}
+
+	parseStateKey (stateKey: string) {
+		stateKey = stateKey.toString();
+
+		if (stateKey.indexOf(this.NEW_KEYWORD) === 0)
+			return {
+				type: 'new',
+				template: stateKey.substring(this.NEW_KEYWORD.length)
+			};
+
+		if (stateKey.indexOf(this.DUPLICATE_KEYWORD) === 0)
+			return {
+				type: 'duplicate',
+				itemId: stateKey.substring(this.DUPLICATE_KEYWORD.length)
+			};
+
+		return null;
+	}
+
+	getDuplicateStateKey (itemId: string | number) {
+		return this.DUPLICATE_KEYWORD.concat(String(itemId));
+	}
+
+	getNewStateKey (templateType: string) {
+		return this.NEW_KEYWORD.concat(templateType);
+	}
+
+	getLocalId (): number {
+		return parseInt(this.NEW_PREFIX.concat(this.getRandomString()), 10);
+	}
+
+	getLocalDuplicateId (): number {
+		return parseInt(this.DUPLICATE_PREFIX.concat(this.getRandomString()), 10);
+	}
+
+	getRandomString () {
+		return Math.random().toString().split('.')[1].substr(0, 8);
+	}
+
+	// note: the changes compiler uses this
+	// might be called with undefined (itemHandler.createRequest)
+	isLocalId (itemId: number | string) {
+		return itemId !== undefined && this.isNewId(itemId) || this.isDuplicateId(itemId);
+	}
+
+	isNewId (itemId: number | string) {
+		return itemId.toString().indexOf(this.NEW_PREFIX) === 0 || itemId === this.NEW_KEYWORD;
+	}
+
+	isDuplicateId (itemId: number | string) {
+		return itemId.toString().indexOf(this.DUPLICATE_PREFIX) === 0 || itemId === this.DUPLICATE_KEYWORD;
+	}
+}

package/src/classes/LockService.ts

@@ -0,0 +1,184 @@
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ItemEntry from "../models/ItemEntry";
+import KeyService from "./KeyService";
+import PromiseService from "./PromiseService";
+import { createPath } from "./Util";
+
+export default class LockService {
+	lockItems = {};
+	promises = {};
+
+	constructor (
+		private apiRequestService: ApiRequestServiceInterface,
+		private errorHandler: ErrorHandlerInterface,
+		private keyService: KeyService,
+		private promiseService: PromiseService
+	) {
+
+	}
+
+	getValue (itemEntry: ItemEntry, map) {
+		const itemType = itemEntry.itemType;
+
+		if (map[itemType] === undefined)
+			return undefined;
+
+		return map[itemType][itemEntry.itemId];
+	}
+
+	setValue (itemEntry: ItemEntry, value, map) {
+		return createPath(
+			map,
+			[itemEntry.itemType, itemEntry.itemId],
+			[{}, value]
+		);
+	}
+
+	getLocks () {
+		return this.lockItems;
+	}
+
+	hasLock (lockTokenId) {
+		for (const itemType in this.lockItems) {
+			for (const itemId in this.lockItems[itemType]) {
+				const lockItem = this.lockItems[itemType][itemId];
+
+				// tslint:disable:triple-equals
+				if (!lockItem.isForeign && lockItem.id == lockTokenId)
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	// should be fast (watched)
+	isLocked (itemEntry: ItemEntry) {
+		const lockItem = this.getValue(itemEntry, this.lockItems);
+
+		if (lockItem === undefined)
+			return false;
+
+		return lockItem.isForeign;
+	}
+
+	getMessage (itemEntry) {
+		const lockItem = this.getValue(itemEntry, this.lockItems);
+
+		if (lockItem === undefined)
+			return undefined;
+
+		if (!lockItem.isForeign)
+			return undefined;
+
+		return lockItem.message;
+	}
+
+	// does not reject when a foreign lock is encountered
+	// is also used by deleteLock
+	fetchCachedLock (itemEntry: ItemEntry) {
+		const lock = this.getValue(itemEntry, this.lockItems);
+
+		if (lock !== undefined)
+			return this.promiseService.when(lock);
+
+		const promise = this.getValue(itemEntry, this.promises);
+
+		if (promise !== undefined)
+			return promise;
+
+		return this.promiseService.when();
+	}
+
+	fetchLock (itemEntry: ItemEntry) {
+		return this.fetchCachedLock(itemEntry).then(lockItem => {
+				if (lockItem !== undefined)
+					return lockItem;
+
+				return this.requestLock(itemEntry);
+			},
+			this.errorHandler.reject
+		).then(lockItem => {
+				return lockItem.isForeign ?
+					this.errorHandler.reject(lockItem.message) :
+					lockItem.token;
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	requestLock (itemEntry: ItemEntry) {
+		const itemType = itemEntry.itemType;
+		const itemId = itemEntry.itemId;
+
+		const promise = this.apiRequestService.create(
+			'Locktoken',
+			this.keyService.getLocalId(),
+			{itemtype: itemType, item: itemId}
+		).then(
+			response => {
+				delete this.promises[itemType][itemId];
+
+				return this.setValue(
+					itemEntry,
+					response.fetchObject(
+						'Locktoken',
+						response.links.Locktoken[0]
+					),
+					this.lockItems
+				);
+			}, error => {
+				delete this.promises[itemType][itemId];
+
+				if (error.code === 301) {
+					return this.setValue(
+						itemEntry,
+						{
+							isForeign: true,
+							message: error.message
+						},
+						this.lockItems
+					);
+				}
+
+				return this.errorHandler.reject(error);
+			}
+		);
+
+		return this.setValue(itemEntry, promise, this.promises);
+	}
+
+	deleteLock (itemEntry) {
+		return this.fetchCachedLock(itemEntry).then(cachedLock => {
+				// undefined: not requested yet
+
+				if (cachedLock === undefined)
+					return;
+
+				if (cachedLock.isForeign) {
+					this.clearLock(itemEntry);
+					return;
+				}
+
+				return this.apiRequestService.delete('Locktoken', cachedLock.id)
+					.then(
+						() => {
+							this.clearLock(itemEntry);
+						},
+						this.errorHandler.reject
+					);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	clearLock (itemEntry) {
+		const itemType = itemEntry.itemType;
+
+		if (this.lockItems[itemType] === undefined)
+			return false;
+
+		return delete this.lockItems[itemType][itemEntry.itemId];
+	}
+}

package/src/classes/ModuleChangesCompiler.ts

@@ -0,0 +1,123 @@
+import ItemEntry from "../models/ItemEntry";
+import CollectionCache from "./CollectionCache";
+import ItemCache from "./ItemCache";
+import ItemEntryService from "./ItemEntryService";
+import { hasProperties } from "./Util";
+
+const EMPTY_ENTRY = {};
+
+export default class ModuleChangesCompiler {
+	parentMap;
+	destination;
+
+	constructor (
+		private itemEntryService: ItemEntryService,
+		private rootItemEntry: ItemEntry,
+		private singleItemCache: ItemCache,
+		private collectionCache: CollectionCache
+	) {
+	}
+
+	process () {
+		this.parentMap = this.createParentMap(this.singleItemCache);
+		this.processItems(this.rootItemEntry.itemType, [this.rootItemEntry], {});
+	}
+
+	private createParentMap (itemCache) {
+		const result = {};
+
+		itemCache.forEach(itemEntry => {
+				const itemType = itemEntry.itemType;
+				const parent = itemEntry.parent;
+
+				if (parent === undefined) // we don't care for items that are not linked to the root item
+					return;
+
+				const parentType = parent.itemType;
+				const parentId = parent.itemId;
+
+				if (result[parentType] === undefined)
+					result[parentType] = {};
+
+				let mapEntry = result[parentType];
+
+				if (mapEntry[parentId] === undefined)
+					mapEntry[parentId] = {};
+
+				mapEntry = mapEntry[parentId];
+
+				if (mapEntry[itemType] === undefined)
+					mapEntry[itemType] = [];
+
+				mapEntry[itemType].push(itemEntry);
+			}
+		);
+
+		return result;
+	}
+
+	private processItems (itemType, itemEntries: ItemEntry[], linkAccumulator) {
+		if (this.destination[itemType] === undefined)
+			this.destination[itemType] = {};
+
+		if (linkAccumulator[itemType] === undefined)
+			linkAccumulator[itemType] = [];
+
+		for (const itemEntry of itemEntries) {
+			const itemId = itemEntry.itemId;
+
+			// each item only has a single parent, so we can safely do this
+			if (this.destination[itemType][itemId] !== undefined)
+				continue;
+
+			linkAccumulator[itemType].push(itemId);
+
+			this.destination[itemType][itemId] = this.processItem(itemEntry);
+		}
+	}
+
+	private processItem (itemEntry) {
+		const itemType = itemEntry.itemType;
+		const itemId = itemEntry.itemId;
+		const childItems = this.getItemsByParent(itemType, itemId);
+		const childCollections = this.collectionCache.getCollectionsByParent(itemType, itemId);
+		const values = this.itemEntryService.formatRequest(itemEntry);
+		const links = {};
+
+		for (const childType in childItems)
+			this.processItems(childType, childItems[childType], links);
+
+		for (const collectionEntry of childCollections) {
+			if (collectionEntry.options.query !== null)
+				continue;
+
+			this.processItems(collectionEntry.itemType, collectionEntry.items, links);
+		}
+
+		const hasValues = hasProperties(values);
+		const hasLinks = hasProperties(links);
+
+		if (hasValues && hasLinks)
+			return {values: values, links: links};
+
+		if (hasValues)
+			return {values: values};
+
+		if (hasLinks)
+			return {links: links};
+
+		return EMPTY_ENTRY;
+	}
+
+	private getItemsByParent (parentType, parentId) {
+		const mapEntry = this.parentMap[parentType];
+
+		if (mapEntry === undefined)
+			return {};
+
+		if (mapEntry[parentId] === undefined)
+			return {};
+
+		return mapEntry[parentId];
+	}
+}

package/src/classes/PromiseService.ts

@@ -0,0 +1,19 @@
+import { all, defer, reject, when } from 'q';
+
+export default class PromiseService {
+	all (iterable): Promise<any> {
+		return all(iterable);
+	}
+
+	when (value?): Promise<any> {
+		return when(value);
+	}
+
+	reject (value?): Promise<any> {
+		return reject(value);
+	}
+
+	defer (): { resolve (value?); reject (value?); promise: Promise<any>; } {
+		return defer();
+	}
+}