@rentman/rm-core 1.0.0 → 1.0.2

package/src/models/CollectionEntry.ts

@@ -1,448 +0,0 @@
-import CollectionEntryService from "../classes/CollectionEntryService";
-import ItemEntryService from "../classes/ItemEntryService";
-import ItemRequestService from "../classes/ItemRequestService";
-import KeyService from "../classes/KeyService";
-import PromiseService from "../classes/PromiseService";
-import QueryService from "../classes/QueryService";
-
-import { inArray } from "../classes/Util";
-import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
-import CollectionResource from "./CollectionResource";
-import ItemEntry from "./ItemEntry";
-
-let currentId = 0;
-
-export default class CollectionEntry {
-	id: number = currentId++;
-	query: any;
-	columns: any;
-
-	parent: null | { itemType: string, itemId: string } = null;
-
-	initial: ItemEntry[] = [];
-	items: ItemEntry[] = [];
-
-	resources: CollectionResource[] = [];
-	deferred: any;
-	promise: any;
-	reloadQueued: boolean;
-
-	constructor (
-		private errorHandler: ErrorHandlerInterface,
-		private collectionEntryService: CollectionEntryService,
-		private itemRequestService: ItemRequestService,
-		private itemEntryService: ItemEntryService,
-		private keyService: KeyService,
-		private queryService: QueryService,
-		private promiseService: PromiseService,
-		public itemType: string,
-		public options: any
-	) {
-		this.deferred = this.promiseService.defer();
-
-		this.itemType = itemType;
-		this.options = options;
-		this.query = collectionEntryService.createQuery(options);
-	}
-
-	isDeferred () {
-		return this.promise !== undefined;
-	}
-
-	resolve (itemEntryResource) {
-		const deferred = this.deferred;
-
-		this.columns = itemEntryResource.columns;
-		this.initial = itemEntryResource.items;
-		this.items = itemEntryResource.items.slice();
-
-		delete this.deferred;
-		delete this.promise;
-
-		deferred.resolve(this);
-
-		return this;
-	}
-
-	isLocal () {
-		const parent = this.parent;
-
-		if (parent === null)
-			return false;
-
-		return this.keyService.isLocalId(parent.itemId);
-	}
-
-	matchParent (itemType, itemId) {
-		const parent = this.parent;
-
-		if (parent === null)
-			return false;
-
-		// == to compare itemIds
-		return parent.itemType === itemType && parent.itemId == itemId;
-	}
-
-	forEach (callback) {
-		const modified = this.items;
-
-		for (const mod of modified)
-			callback(mod);
-	}
-
-	getItemById (itemId) {
-		const modified = this.items;
-
-		for (const mod of modified) {
-			if (mod.itemId === itemId)
-				return mod;
-		}
-	}
-
-	getIdArray (accumulator = {}) {
-		return this.collectionEntryService.getIdArray(this.items, accumulator);
-	}
-
-	addItems (itemEntries, resultResource, updateInitial = false, enableCallback = true) {
-		// local entry might be added multiple times (extend?)
-		if (itemEntries.length === 0)
-			return [];
-
-		const collectionResources = this.resources;
-		const parent = this.parent;
-		const parentColumn = this.columns.link;
-
-		if (updateInitial) {
-			const initial = this.initial;
-			const entriesAddedToInitial = [];
-
-			for (const itemEntry of itemEntries) {
-				// when saving, items that might already be in modified are added to initial
-				if (initial.indexOf(itemEntry) === -1) {
-					initial.push(itemEntry);
-					entriesAddedToInitial.push(itemEntry);
-				}
-			}
-
-			if (entriesAddedToInitial.length > 0) {
-				for (const collectionResource of collectionResources)
-					collectionResource.options.onAddInitial(entriesAddedToInitial, this);
-			}
-		}
-
-		const modified = this.items;
-		const entriesAddedToModified = [];
-
-		for (const itemEntry of itemEntries) {
-			if (modified.indexOf(itemEntry) === -1) {
-				if (parent !== null) {
-					itemEntry.parent = parent;
-
-					if (parentColumn !== null && itemEntry.modified !== undefined)
-						itemEntry.modified[parentColumn.id] = parent.itemId;
-				}
-
-				modified.push(itemEntry);
-				entriesAddedToModified.push(itemEntry);
-			}
-		}
-
-		if (entriesAddedToModified.length > 0) {
-			let result;
-
-			for (const collectionResource of collectionResources) {
-				const addedResources = collectionResource.addItemResources(entriesAddedToModified);
-
-				if (collectionResource === resultResource) {
-					result = addedResources;
-
-					if (enableCallback)
-						collectionResource.callOnAdd(addedResources);
-				} else
-					collectionResource.callOnAdd(addedResources);
-			}
-
-			return result;
-		} else
-			return resultResource === null ? null : [];
-	}
-
-	removeItems (idArray, resultResource, updateInitial, enableCallback?) {
-		if (idArray.length === 0)
-			return [];
-
-		return this.handleRemovedItems(itemEntry => {
-				return inArray(itemEntry.itemId, idArray);
-			},
-			resultResource,
-			updateInitial,
-			enableCallback
-		);
-	}
-
-	clear (resultResource, updateInitial, enableCallback?) {
-		return this.handleRemovedItems(
-			() => {
-				return false;
-			},
-			resultResource,
-			updateInitial,
-			enableCallback
-		);
-	}
-
-	handleRemovedItems (filterFunction, resultResource, updateInitial, enableCallback) {
-		if (enableCallback === undefined)
-			enableCallback = true;
-
-		const collectionResources = this.resources;
-		const removedFromModified = this.collectionEntryService.filterArray(this.items, filterFunction);
-		const removedFromInitial = updateInitial ? this.collectionEntryService.filterArray(this.initial, filterFunction) : [];
-
-		if (removedFromInitial.length > 0) {
-			for (const collectionResource of collectionResources)
-				collectionResource.options.onRemoveInitial(removedFromInitial, this);
-		}
-
-		if (removedFromModified.length === 0)
-			return resultResource === null ? null : [];
-
-		let result;
-
-		for (const removedFromMod of removedFromModified)
-			this.itemEntryService.deactivateResources(removedFromMod);
-
-		for (const collectionResource of collectionResources) {
-			const removedResources = collectionResource.removeItemResources(removedFromModified);
-
-			if (collectionResource === resultResource) {
-				result = removedResources;
-
-				if (enableCallback)
-					collectionResource.callOnRemove(removedResources);
-			} else
-				collectionResource.callOnRemove(removedResources);
-		}
-
-		return result;
-	}
-
-	expand (newColumns) {
-		const itemType = this.itemType;
-
-		if (newColumns.length === 0)
-			return this.promiseService.when(this);
-
-		this.promise = this.itemRequestService.requestItems(this, undefined, newColumns).then(response => {
-				const responseItems = response.items[itemType];
-				const columnExpansion = this.itemRequestService.processExpansion(newColumns, response, itemType, this.items);
-
-				this.handleRemovedItems.call(
-					this, itemEntry => {
-						return responseItems[itemEntry.itemId] !== undefined || this.itemEntryService.isLocal(itemEntry);
-					},
-					null,
-					true,
-					true
-				);
-
-				this.updateColumns(columnExpansion);
-
-				delete this.promise;
-				return this;
-			},
-			this.errorHandler.reject
-		);
-
-		return this.promise;
-	}
-
-	extendQuery (callback) {
-		const options = this.options;
-
-		if (callback === undefined)
-			return this.query;
-
-		options.queryParams = callback(options.queryParams);
-
-		return this.query = this.collectionEntryService.createQuery(options);
-	}
-
-	extend (queryCallback, collectionResource, enableCallback?, updateInitial?) {
-		const extendedQuery = this.extendQuery(queryCallback).object;
-		const fullQuery = this.queryService.addAndCondition(
-			extendedQuery,
-			this.queryService.createNotIn(this.getIdArray())
-		);
-
-		// todo: also do the limit check in batchExtend
-		const promise = this.itemRequestService.requestItems(
-			this,
-			// When there's a limit we want to fetch all items because we will do sorting and splicing of the excess items
-			this.options.limit !== null ?
-				extendedQuery :
-				fullQuery
-		).then(response => {
-				// removeAbsentItems(response); TODO: we can only do this when we request *all* the items
-				return this.itemRequestService.processResponse(
-					response,
-					response.links[this.itemType],
-					this.parent,
-					this.columns
-				);
-			},
-			this.errorHandler.reject
-		).then(itemEntries => {
-				delete this.promise;
-
-				return this.addItems(itemEntries, collectionResource, updateInitial, enableCallback);
-			},
-			this.errorHandler.reject
-		);
-
-		this.promise = promise.then(
-			() => {
-				return this;
-			},
-			this.errorHandler.reject
-		);
-
-		return promise;
-	}
-
-	queueReload () {
-		this.reloadQueued = true;
-		this.deferred = this.promiseService.defer();
-		this.promise = this.deferred.promise;
-	}
-
-	updateColumns (columnExpansion) {
-		const columnInfo = columnExpansion(this.columns, false);
-
-		this.options.columns = columnInfo.request;
-		this.columns = columnInfo;
-	}
-
-	getAddedItems (returnItemIds = false) {
-		const initial = this.initial;
-		const modified = this.items;
-		const result = [];
-
-		for (const itemEntry of modified) {
-			if (initial.indexOf(itemEntry) === -1)
-				result.push(returnItemIds ? itemEntry.itemId : itemEntry);
-		}
-
-		return result;
-	}
-
-	getRemovedItems (returnItemIds = false) {
-		const initial = this.initial;
-		const modified = this.items;
-		const result = [];
-
-		for (const itemEntry of initial) {
-			if (modified.indexOf(itemEntry) === -1)
-				result.push(returnItemIds ? itemEntry.itemId : itemEntry);
-		}
-
-		return result;
-	}
-
-	getUpdatedItems () {
-		const modified = this.items;
-		const result = [];
-
-		for (const itemEntry of modified) {
-			if (!this.itemEntryService.isLocal(itemEntry) && this.itemEntryService.hasChanges(itemEntry))
-				result.push(itemEntry);
-		}
-
-		return result;
-	}
-
-	hasAddedItems () {
-		return this.items.length > this.initial.length;
-	}
-
-	hasRemovedItems () {
-		return this.initial.length > this.items.length;
-	}
-
-	hasUpdatedItems () {
-		const modified = this.items;
-
-		for (const mod of modified) {
-			if (this.itemEntryService.hasChanges(mod))
-				return true;
-		}
-
-		return false;
-	}
-
-	getCurrentResource () {
-		const resources = this.resources;
-
-		return resources[resources.length - 1];
-	}
-
-	clearResources (isSubtabChange = false) {
-		const itemEntries = this.items; // TODO: initial
-		const currentResources = this.resources;
-		const newResources = [];
-
-		// we'll add the item resources back in later
-		for (const itemEntry of itemEntries)
-			this.itemEntryService.clearResources(itemEntry);
-
-		for (const collectionResource of currentResources) {
-			if (collectionResource.options[isSubtabChange ? 'clearOnSubTabChange' : 'clearOnTabChange'])
-				continue;
-
-			newResources.push(collectionResource);
-
-			const itemResources = collectionResource.items;
-
-			for (const itemResource of itemResources) {
-				itemResource.entry.resources.push(itemResource); // resources should be empty by now :-)
-			}
-		}
-
-		this.resources = newResources;
-	}
-
-	// this doesn't revert updates
-	revertChanges () {
-		const resources = this.resources;
-		const removedItems = this.getRemovedItems();
-		const addedItems = this.getAddedItems(true);
-
-		for (const resource of resources) {
-			resource.addItemResources(removedItems);
-			resource.removeItemResources(addedItems);
-		}
-
-		this.items = this.initial.slice();
-	}
-
-	onItemsCreated (conversionMap) {
-		const resources = this.resources;
-
-		for (const resource of resources) {
-			resource.rebuildMap();
-			resource.options.onItemsCreated(conversionMap);
-		}
-	}
-
-	getUpdatedItemColumns (conversionMap) {
-		const itemColumns = this.columns.item;
-		const result = {};
-
-		for (const column of itemColumns) {
-			if (conversionMap[column.apiColumn.itemType] !== undefined)
-				result[column.id] = column;
-		}
-
-		return result;
-	}
-}

package/src/models/CollectionResource.ts

@@ -1,223 +0,0 @@
-import { filterArray } from "../classes/Util";
-import ItemResourceFactory from "../factories/ItemResourceFactory";
-import CollectionEntry from './CollectionEntry';
-import ItemEntry from "./ItemEntry";
-import ItemResource from "./ItemResource";
-
-export default class CollectionResource {
-	columns;
-	items: ItemResource[];
-	itemIdMap: {};
-
-	constructor (
-		private itemResourceFactory: ItemResourceFactory,
-		public entry: CollectionEntry,
-		public options
-	) {
-		this.columns = entry.columns.response;
-		this.itemIdMap = {};
-		this.items = [];
-
-		entry.resources.push(this);
-
-		this.addItemResources(entry.items);
-	}
-
-	getItemById (itemId) {
-		return this.itemIdMap[itemId];
-	}
-
-	rebuildMap () {
-		const itemResources = this.items;
-		const itemIdMap = {};
-
-		for (const itemResource of itemResources) {
-			itemIdMap[itemResource.entry.itemId] = itemResource;
-		}
-
-		this.itemIdMap = itemIdMap;
-	}
-
-	addItemResources (itemEntries: ItemEntry[]) { // should be fast
-		if (itemEntries.length === 0)
-			return [];
-
-		const result = [];
-		const options = this.options;
-		const items = this.items;
-		const itemIdMap = this.itemIdMap;
-		const constructor = this.itemResourceFactory.getConstructor(
-			{
-				edit: options.editItems,
-				onChange: options.onChange,
-				onDeactivate: options.onDeactivateItem
-			}
-		);
-
-		for (const itemEntry of itemEntries) {
-			const itemId = itemEntry.itemId;
-
-			let itemResource;
-
-			if (itemIdMap[itemId] === undefined) {
-				itemResource = constructor(itemEntry);
-				items.push(itemResource);
-				itemIdMap[itemId] = itemResource;
-			} else
-				itemResource = itemIdMap[itemId];
-
-			result.push(itemResource);
-		}
-
-		return result;
-	}
-
-	removeItemResources (itemEntries) {
-		const result = [];
-
-		filterArray(
-			this.items,
-			itemResource => {
-				for (const itemEntry of itemEntries) {
-					if (itemResource.entry === itemEntry) {
-						result.push(itemResource);
-						delete this.itemIdMap[itemEntry.itemId];
-
-						return false;
-					}
-				}
-
-				return true;
-			}
-		);
-
-		return result;
-	}
-
-	callOnAdd (itemResources: ItemResource[]) {
-		this.options.onAdd(itemResources, this);
-	}
-
-	callOnRemove (itemResources: ItemResource[]) {
-		this.options.onRemove(itemResources, this);
-	}
-
-	forEach (callback) {
-		const itemResources = this.items;
-
-		for (const itemResource of itemResources)
-			callback(itemResource);
-	}
-
-	filter (callback) {
-		const itemResources = this.items;
-		const result = [];
-
-		for (const itemResource of itemResources) {
-			if (callback(itemResource))
-				result.push(itemResource);
-		}
-
-		return result;
-	}
-
-	first (callback) {
-		const itemResources = this.items;
-
-		for (const itemResource of itemResources) {
-			if (callback(itemResource))
-				return itemResource;
-		}
-
-		return null;
-	}
-
-	some (callback) {
-		return this.first(callback) !== null;
-	}
-
-	groupBy (argument) {
-		const itemsResources = this.items;
-		const result = {};
-
-		if (typeof argument === 'string') {
-			for (const itemResource of itemsResources) {
-				const value = itemResource.fields[argument];
-
-				if (result[value] === undefined)
-					result[value] = [];
-
-				result[value].push(itemResource);
-			}
-		}
-
-		if (typeof argument === 'function') {
-			for (const itemResource of itemsResources) {
-				const value = argument(itemResource);
-
-				if (value === null)
-					continue;
-
-				if (result[value] === undefined)
-					result[value] = [];
-
-				result[value].push(itemResource);
-			}
-		}
-
-		return result;
-	}
-
-	map (argument) {
-		const itemResources = this.items;
-		const length = itemResources.length;
-		const result = new Array(length);
-
-		if (typeof argument === 'string') {
-			for (let i = 0; i < length; i++)
-				result[i] = itemResources[i].fields[argument];
-		}
-
-		if (typeof argument === 'function') {
-			for (let i = 0; i < length; i++)
-				result[i] = argument(itemResources[i]);
-		}
-
-		return result;
-	}
-
-	reduce (callback, value) {
-		const itemResources = this.items;
-
-		for (const itemResource of itemResources)
-			value = callback(itemResource, value);
-
-		return value;
-	}
-
-	extend (queryCallback, returnAllItems, enableCallbacks) {
-		if (enableCallbacks === undefined)
-			enableCallbacks = true;
-
-		return this.entry.extend(queryCallback, this, enableCallbacks)
-			.then(itemResources => {
-				return returnAllItems ? this.items : itemResources;
-			});
-	}
-
-	deactivate () {
-		this.options.onDeactivateCollection(this);
-	}
-
-	clearResource () {
-		const collectionResources = this.entry.resources;
-		const itemResources = this.items;
-		const index = collectionResources.indexOf(this);
-
-		if (index !== -1)
-			collectionResources.splice(index, 1);
-
-		for (const itemResource of itemResources)
-			itemResource.clearResource();
-	}
-}

package/src/models/EditResource.ts

@@ -1,15 +0,0 @@
-import ItemEntryService from "../classes/ItemEntryService";
-import ItemEntry from "./ItemEntry";
-import ItemResource from "./ItemResource";
-
-export class EditResource extends ItemResource {
-	fields;
-
-	constructor (itemEntryService: ItemEntryService, entry: ItemEntry, options) {
-		super(itemEntryService, entry, options);
-
-		itemEntryService.setModified(entry);
-
-		this.fields = entry.modified;
-	}
-}

package/src/models/ItemEntry.ts

@@ -1,24 +0,0 @@
-import ItemResource from "./ItemResource";
-
-let currentId = 0;
-
-export default class ItemEntry {
-	entryId: number;
-
-	modified;
-	parent: null | { itemType: string, itemId: string } = null;
-
-	deferRequest = false;
-	deferred;
-
-	constructor (
-		public itemType: string,
-		public itemId: number,
-		public columns?,
-		public initial = {},
-		public derived = {},
-		public resources: ItemResource[] = []
-	) {
-		this.entryId = ++currentId;
-	}
-}