@rentman/rm-core 1.0.0

package/src/classes/CreateRequest.ts

@@ -0,0 +1,158 @@
+import RequestColumnExpansionFactory from "../factories/RequestColumnExpansionFactory";
+import CollectionHandler from "./CollectionHandler";
+import ItemEntryService from "./ItemEntryService";
+import KeyService from "./KeyService";
+import { getPath } from "./Util";
+
+export default class CreateRequest {
+	requests = [];
+
+	constructor (
+		private collectionHandler: CollectionHandler,
+		private requestColumnExpansionFactory: RequestColumnExpansionFactory,
+		private itemEntryService: ItemEntryService,
+		private keyService: KeyService,
+		private compilation,
+		private parameterMap,
+		private breakupByParent = false
+	) {
+	}
+
+	finalizeRequest (requestResource) {
+		const collectionMap = requestResource.collections;
+		const columnExpansion = requestResource.columns;
+
+		for (const collectionId in collectionMap) {
+			const entry = collectionMap[collectionId];
+
+			if (entry.fitting.length > 0)
+				columnExpansion.expand(entry.collection.columns);
+		}
+
+		requestResource.request.columns = columnExpansion.get();
+
+		return requestResource;
+	}
+
+	setRequestParent (parentType, requestResource) {
+		const request = requestResource.request;
+
+		if (parentType === 'Void')
+			return false;
+
+		request.parentType = parentType;
+		request.parentId = {};
+
+		return true;
+	}
+
+	run () {
+		if (this.breakupByParent) {
+			for (const parentType in this.compilation) {
+				const parentMap = this.compilation[parentType];
+
+				for (const parentId in parentMap) {
+					if (this.keyService.isLocalId(parentId))
+						continue;
+
+					const requestResource = this.initializeRequest();
+
+					this.extendRequest(
+						parentMap[parentId],
+						this.setRequestParent(parentType, requestResource) ? parentId : null,
+						requestResource
+					);
+
+					this.requests.push(this.finalizeRequest(requestResource));
+				}
+			}
+		} else {
+			for (const parentType in this.compilation) {
+				const parentMap = this.compilation[parentType];
+				const requestResource = this.initializeRequest();
+				const hasParent = this.setRequestParent(parentType, requestResource);
+
+				let validRequest = false;
+
+				for (const parentId in parentMap) {
+					if (this.keyService.isLocalId(parentId))
+						continue;
+
+					this.extendRequest(
+						parentMap[parentId],
+						hasParent ? parentId : null,
+						requestResource
+					);
+
+					validRequest = true;
+				}
+
+				if (validRequest)
+					this.requests.push(this.finalizeRequest(requestResource));
+			}
+		}
+
+		return this.requests;
+	}
+
+	initializeRequest () {
+		return {
+			request: {
+				requestType: 'create',
+				items: {}
+			},
+			columns: this.requestColumnExpansionFactory.construct(),
+			items: {},
+			collections: {}
+		};
+	}
+
+	private extendRequest (itemEntries, requestParentId, destination) {
+		const request = destination.request;
+		const itemEntryMap = destination.items;
+
+		for (const itemType in itemEntries) {
+			if (request.itemType === undefined)
+				request.itemType = itemType;
+
+			if (itemEntryMap[itemType] === undefined) {
+				itemEntryMap[itemType] = {};
+				request.items[itemType] = {};
+			}
+
+			for (const itemId in itemEntries[itemType]) {
+				const itemEntry = itemEntries[itemType][itemId];
+				const childEntries = getPath(this.compilation, [itemType, itemId]);
+				const itemRequest: any = request.items[itemType][itemId] = {};
+				const parameters = getPath(this.parameterMap, [itemType, itemId]);
+
+				let links;
+
+				if (requestParentId !== null)
+					request.parentId[itemId] = requestParentId;
+
+				destination.columns.expand(itemEntry.columns);
+				this.collectionHandler.expandCollectionMap(itemEntry, destination.collections);
+
+				itemEntryMap[itemType][itemId] = itemEntry;
+
+				itemRequest.values = this.itemEntryService.formatRequest(itemEntry);
+				itemRequest.parameters = parameters;
+
+				if (childEntries === undefined)
+					continue;
+
+				links = itemRequest.links = {};
+
+				for (const childType in childEntries) {
+					links[childType] = [];
+
+					for (const childId in childEntries[childType])
+						links[childType].push(childId);
+				}
+
+				this.extendRequest(childEntries, null, destination);
+			}
+		}
+	}
+}

package/src/classes/ItemAdministrator.ts

@@ -0,0 +1,571 @@
+import ColumnSetFactory from "../factories/ColumnSetFactory";
+import ModuleChangesCompilerFactory from "../factories/ModuleChangesCompilerFactory";
+import ResourceCacheFactory from "../factories/ResourceCacheFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import AuthInterface from '../interfaces/AuthInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import ResourceCacheInterface from '../interfaces/ResourceCacheInterface';
+import CollectionEntryService from "./CollectionEntryService";
+import CollectionHandler from "./CollectionHandler";
+import CollectionResourceService from './CollectionResourceService';
+import ItemEntryService from './ItemEntryService';
+import ItemHandler from './ItemHandler';
+import ItemRequestService from "./ItemRequestService";
+import KeyService from "./KeyService";
+import QueryService from "./QueryService";
+import ResourceCache from "./ResourceCache";
+import { createPath } from "./Util";
+
+export default class ItemAdministrator {
+	constructor (
+		private apiRequestService: ApiRequestServiceInterface,
+		private resourceCacheInterface: ResourceCacheInterface,
+		private authInterface: AuthInterface,
+		private errorHandler: ErrorHandlerInterface,
+		private itemHandler: ItemHandler,
+		private collectionHandler: CollectionHandler,
+		private columnSetFactory: ColumnSetFactory,
+		private itemRequestService: ItemRequestService,
+		private resourceCacheFactory: ResourceCacheFactory,
+		private moduleChangesCompilerFactory: ModuleChangesCompilerFactory,
+		private collectionEntryService: CollectionEntryService,
+		private collectionResourceService: CollectionResourceService,
+		private itemEntryService: ItemEntryService,
+		private keyService: KeyService,
+		private queryService: QueryService
+	) {
+
+	}
+
+	// id can be a keyword or a local id (in case of a refresh)
+	getItemDefinition (itemType: string, itemId: any, options: any) {
+		const stateKey: any = this.keyService.parseStateKey(itemId);
+		const result = {itemType: itemType, options: options, itemId: itemId};
+
+		if (stateKey !== null) {
+			switch (stateKey.type) {
+				case 'new':
+					// if (stateKey.template.length > 0)
+					// 	options.templateOptions = {type: stateKey.template};
+
+					result.itemId = this.keyService.getLocalId();
+					break;
+				case 'duplicate':
+					options.duplicate = stateKey.itemId;
+
+					if (options.templateOptions === undefined) // todo: refactor this
+						options.templateOptions = {};
+
+					if (options.templateOptions.item === undefined)
+						options.templateOptions.item = stateKey.itemId;
+
+					result.itemId = this.keyService.getLocalDuplicateId();
+					break;
+			}
+
+			return result;
+		}
+
+		result.itemId = itemId;
+		return result;
+	}
+
+	createCollectionMap (itemEntries: any[], addToTab: boolean) {
+		const resourceCache = this.getResourceCache();
+		const collectionCache = resourceCache.collections;
+		const result = {};
+
+		for (const itemEntry of itemEntries) {
+			if (addToTab)
+				resourceCache.addSingleItem(itemEntry, {}, false);
+
+			this.collectionHandler.expandCollectionMap(itemEntry, result, collectionCache);
+		}
+
+		return result;
+	}
+
+	getItemById (itemType: string, itemId: number, options: any) {
+		return this.itemHandler.fetchItem(
+			itemType, itemId, options
+		).then(
+			itemEntry => {
+				return this.addSingleItem(itemEntry, options, false);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getItemsById (itemType: string, itemIds: number[], options: any) {
+		return this.itemHandler.fetchItems(itemType, itemIds, this.itemEntryService.processOptions(options)).then(
+			itemEntries => {
+				return this.addSingleItems(itemEntries, options);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getItemsByQuery (itemType: string, query: any, options: any) {
+		const entryOptions = this.itemEntryService.processOptions(options);
+		const requestColumns = {};
+
+		requestColumns[itemType] = entryOptions.columns;
+
+		return this.apiRequestService.query(
+			itemType,
+			this.queryService.addParentCondition(query, entryOptions.parent),
+			requestColumns
+		).then(
+			response => {
+				return this.itemRequestService.processResponse(
+					response,
+					response.links[itemType],
+					entryOptions.parent,
+					this.columnSetFactory.construct(itemType, entryOptions.columns, response.fetchColumnsObject())
+				);
+			},
+			this.errorHandler.reject
+		).then(
+			itemEntries => {
+				return this.addSingleItems(itemEntries, options);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getDuplicateById (itemType: string, duplicateId: number, options: any) {
+		if (options === undefined)
+			options = {};
+
+		options.edit = true;
+
+		const definition = this.getItemDefinition(
+			itemType,
+			this.keyService.getDuplicateStateKey(duplicateId),
+			options
+		);
+
+		return this.getItemByDef(definition, false);
+	}
+
+	getNewResource (itemType: string, options: any, returnLinks: boolean, isRoot: boolean) {
+		if (options === undefined)
+			options = {};
+
+		options.edit = true;
+
+		if (isRoot === undefined)
+			isRoot = false;
+
+		return this.itemHandler.fetchItem(
+			itemType,
+			this.keyService.getLocalId(),
+			this.itemEntryService.processOptions(options)
+		).then(
+			(itemEntryResource: any) => {
+				const main = this.addSingleItem(itemEntryResource.main, options, isRoot);
+				const linked = this.processLinkedItems(itemEntryResource.linked, options, true); // do this beforehand
+
+				return returnLinks ? {main: main, linked: linked} : main;
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getCollectionDef (itemType: string, options: any) {
+		return {
+			itemType: itemType,
+			options: {
+				entry: this.collectionEntryService.processOptions(options), // we need the default column value
+				resource: this.collectionResourceService.processOptions(options)
+			}
+		};
+	}
+
+	getLinkCollectionsDef (linkType: string, linkIdArray: number[], itemType: string, linkField: string, options: any) {
+		return {
+			itemType: itemType,
+			linkType: linkType,
+			linkIdArray: linkIdArray,
+			linkField: linkField,
+			options: {
+				entry: this.collectionEntryService.processOptions(options),
+				resource: this.collectionResourceService.processOptions(options)
+			}
+		};
+	}
+
+	/** @deprecated */
+	getCollection (itemType: string, query: any, options: any) {
+		const resourceCache = this.getResourceCache();
+		const entryOptions = this.collectionEntryService.processOptions(options);
+
+		entryOptions.query = query;
+
+		return this.collectionHandler.fetch(
+			itemType,
+			entryOptions,
+			resourceCache.items,
+			resourceCache.deferredCollections
+		).then(
+			entry => {
+				return this.addCollection(entry, options);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	_getCollection (itemType: string, options: any) {
+		const resourceCache = this.getResourceCache();
+
+		return this.collectionHandler.fetch(
+			itemType,
+			this.collectionEntryService.processOptions(options),
+			resourceCache.items,
+			resourceCache.deferredCollections
+		).then(
+			entry => {
+				return this.addCollection(entry, options);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getCollectionFromDef (definition: any) {
+		const resourceCache = this.getResourceCache();
+
+		return this.collectionHandler.fetch(
+			definition.itemType,
+			definition.options.entry,
+			resourceCache.items,
+			resourceCache.deferredCollections
+		).then(
+			entry => {
+				return this.addCollection(
+					entry,
+					definition.options.resource,
+					false
+				);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getLinkCollection (linkType: string, linkId: number, itemType: string, options: any) {
+		const resourceCache = this.getResourceCache();
+		const entryOptions = this.collectionEntryService.processOptions(options);
+
+		entryOptions.parent = {itemType: linkType, itemId: linkId};
+
+		return this.collectionHandler.fetch(
+			itemType,
+			entryOptions,
+			resourceCache.items,
+			resourceCache.deferredCollections
+		).then(
+			entry => {
+				return this.addCollection(entry, options);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getLinkCollections (linkType: string, linkIdArray: number[], itemType: string, options: any) {
+		return this.collectionHandler.batchFetch(
+			linkType,
+			linkIdArray,
+			itemType,
+			this.collectionEntryService.processOptions(options),
+			this.getResourceCache().deferredCollections
+		).then(
+			collectionEntries => {
+				return this.addCollections(
+					collectionEntries,
+					this.collectionEntryService.processOptions(options)
+				);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getLinkCollectionsFromDef (definition: any) {
+		return this.collectionHandler.batchFetch(
+			definition.linkType,
+			definition.linkIdArray,
+			definition.itemType,
+			definition.options.entry,
+			this.getResourceCache().deferredCollections
+		).then(
+			collectionEntries => {
+				return this.addCollections(
+					collectionEntries,
+					definition.options.resource
+				);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	getAllLinkCollections (linkType: string, itemType: string, options: any) {
+		// 			var requestColumns = {};
+		// 			requestColumns[linkType] = ['id'];
+
+		return this.apiRequestService.query(linkType, {}, {})
+			.then(
+				response => {
+					return this.getLinkCollections(
+						linkType,
+						response.links[linkType],
+						itemType,
+						options
+					);
+				},
+				this.errorHandler.reject
+			);
+	}
+
+	getItemByDef (definition: any, isRoot: boolean) {
+		return this.itemHandler.fetchItem(
+			definition.itemType,
+			definition.itemId,
+			this.itemEntryService.processOptions(definition.options)
+		).then(
+			itemEntryResource => {
+				let mainEntry;
+
+				if (itemEntryResource.linked !== undefined) {
+					this.processLinkedItems(itemEntryResource.linked, definition.options, false);
+					mainEntry = itemEntryResource.main;
+				} else
+					mainEntry = itemEntryResource;
+
+				return this.addSingleItem(mainEntry, definition.options, isRoot); // isRoot
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	cloneItem (newItemId: number, itemResource: any, options: any) {
+		return this.addSingleItem(
+			this.itemHandler.cloneItem(newItemId, itemResource.entry),
+			options
+		);
+	}
+
+	cloneCollection (collectionResource: any, options: any, conversionMap: any) {
+		return this.addCollection(
+			this.collectionHandler.clone(
+				collectionResource.entry,
+				this.collectionEntryService.processOptions(options),
+				conversionMap
+			),
+			options
+		);
+	}
+
+	/**
+	 * @deprecated
+	 */
+	saveCurrentTab (closeTab, parameters, breakupByParent, onAfterCreateCallback, keepTabHeading) {
+		return this.saveCurrentResourceCache(closeTab, parameters, breakupByParent, onAfterCreateCallback, keepTabHeading);
+	}
+
+	saveCurrentResourceCache (closeTab: boolean, parameters: any, breakupByParent = false, onAfterCreateCallback: any, keepTabHeading = false) {
+		return this.getResourceCache()
+			.save(closeTab, parameters, breakupByParent, onAfterCreateCallback).then(
+				conversionMap => {
+					if (closeTab)
+						return conversionMap;
+
+					return this.resourceCacheInterface.updateTabParams(conversionMap, !keepTabHeading).then(
+						() => conversionMap,
+						this.errorHandler.reject
+					);
+				},
+				this.errorHandler.reject
+			);
+	}
+
+	getCurrentCollections () {
+		return this.getResourceCache().collections;
+	}
+
+	getCurrentItems () {
+		return this.getResourceCache().items;
+	}
+
+	getCurrentChanges () {
+		const resourceCache = this.getResourceCache();
+
+		if (resourceCache.rootItem === undefined)
+			throw new Error('itemAdministrator: No root item!');
+
+		return this.moduleChangesCompilerFactory.construct(resourceCache.rootItem, resourceCache.items, resourceCache.collections).process();
+	}
+
+	// used in timeRegistrationController
+	addSingleItem (itemEntry: any, options: any, isRoot?: boolean) {
+		return this.getResourceCache().addSingleItem(itemEntry, options, isRoot);
+	}
+
+	addSingleItems (itemEntries: any[], options: any) {
+		const resourceCache = this.getResourceCache();
+		const result = [];
+
+		for (const itemEntry of itemEntries)
+			result.push(resourceCache.addSingleItem(itemEntry, options, false));
+
+		return result;
+	}
+
+	// used in warehouseItemCacheFactory
+	addCollection (collectionEntry: any, resourceOptions: any, processOptions?: any) {
+		if (processOptions === undefined)
+			processOptions = true;
+
+		return this.getResourceCache().addCollection(
+			collectionEntry,
+			processOptions ? this.collectionEntryService.processOptions(resourceOptions) : resourceOptions
+		);
+	}
+
+	addCollections (collectionEntries: any[], resourceOptions: any) {
+		const resourceCache = this.getResourceCache();
+		const result = {};
+
+		for (const parentId in collectionEntries) {
+			result[parentId] = resourceCache.addCollection(
+				collectionEntries[parentId],
+				resourceOptions
+			);
+		}
+
+		return result;
+	}
+
+	processLinkedItems (linkedEntries: any[], options: any, addToCollections: boolean) {
+		const resourceCache = this.getResourceCache();
+		const collectionCache = resourceCache.collections;
+		const itemResources = {};
+
+		for (const entry of linkedEntries) {
+			const itemType = entry.itemType;
+			const itemEntries = entry.itemEntries;
+			const collectionMap = {};
+
+			itemResources[itemType] = [];
+
+			for (const itemEntry of itemEntries) {
+				itemResources[itemType].push(resourceCache.addSingleItem(itemEntry, options, false));
+
+				if (addToCollections)
+					this.collectionHandler.expandCollectionMap(itemEntry, collectionMap, collectionCache);
+
+				if (itemType === 'Projectnotitie') {
+					createPath(
+						resourceCache.tabRequestParameters,
+						[itemEntry.itemType, itemEntry.itemId],
+						[{}, {no_notification: true}]
+					);
+				}
+			}
+
+			// the itemEntries are in top-down order, so call for each item type separately
+			if (addToCollections)
+				this.collectionHandler.addToCollections(collectionMap, false);
+		}
+
+		return itemResources;
+	}
+
+	/**
+	 * @deprecated
+	 */
+	getTabEntry (): ResourceCache {
+		return this.getResourceCache();
+	}
+
+	getResourceCache (): ResourceCache {
+		return this.resourceCacheInterface.getCacheManager(this.authInterface.getUserId());
+	}
+
+	/**
+	 * @deprecated
+	 */
+	resetTabEntry () {
+		return this.resetResourceCache();
+	}
+
+	resetResourceCache () {
+		const oldResourceCache = this.getResourceCache();
+		const resourceCache = this.resourceCacheFactory.construct();
+
+		oldResourceCache.clearResources();
+
+		this.resourceCacheInterface.setCacheManager(this.authInterface.getUserId(), resourceCache);
+	}
+
+	addToCollections (itemEntries: any[], resultCollectionResource: any) {
+		return this.collectionHandler.addToCollections(
+			this.createCollectionMap(itemEntries, true),
+			false,
+			resultCollectionResource
+		);
+	}
+
+	removeFromCollections (itemEntries: any[], resultCollectionResource) {
+		return this.collectionHandler.removeFromCollections(
+			this.createCollectionMap(itemEntries, false),
+			false,
+			resultCollectionResource
+		);
+	}
+
+	updateItemIdMap (collectionMap: any, conversionMap) {
+		if (conversionMap === undefined)
+			return;
+
+		for (const oldId in conversionMap) {
+			const newId = conversionMap[oldId];
+
+			if (collectionMap[oldId] === undefined)
+				continue;
+
+			collectionMap[newId] = collectionMap[oldId];
+			delete collectionMap[oldId];
+		}
+	}
+
+	createCollectionResource (collectionEntry: any, resourceOptions: any, processOptions?: any) {
+		return this.addCollection(collectionEntry, resourceOptions, processOptions);
+	}
+
+	createItemResource (itemEntry: any, options: any, isRoot: boolean) {
+		return this.addSingleItem(itemEntry, options, isRoot);
+	}
+
+	createItemResources (itemEntries: any[], options: any) {
+		return this.addSingleItems(itemEntries, options);
+	}
+
+	/**
+	 * @deprecated
+	 */
+	onBeforeSave (key: string, callback) {
+		return this.getResourceCache().registerCallback('onBeforeSave', key, callback);
+	}
+
+	/**
+	 * @deprecated
+	 */
+	onSaveSuccess (key: string, callback) {
+		return this.getResourceCache().registerCallback('onSaveSuccess', key, callback);
+	}
+
+	/**
+	 * @deprecated
+	 */
+	onSaveWithoutClosing (key: string, callback) {
+		return this.getResourceCache().registerCallback('onSaveWithoutClosing', key, callback);
+	}
+}