@rentman/rm-core 1.0.0 → 1.0.2

package/src/classes/ItemRequestService.ts

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

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

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

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

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

@@ -1,19 +0,0 @@
-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();
-	}
-}