@rentman/rm-core 1.0.0

package/src/classes/QueryMatcher.ts

@@ -0,0 +1,135 @@
+import * as moment from 'moment';
+import ApiFormatter from './ApiFormatter';
+import { hasProperties, inArray } from './Util';
+
+const MAYBE = 'maybe';
+
+export default class QueryMatcher {
+	constructor (
+		private apiFormatter: ApiFormatter,
+		public parentType: string,
+		public parentId: number,
+		public fields: object,
+		public itemType?: string
+	) {
+
+	}
+
+	private compareValues (value, queryValue) {
+		if (moment.isMoment(queryValue))
+			return this.apiFormatter.compareMomentObjects(queryValue, value);
+
+		if (moment.isDuration(queryValue))
+			return this.apiFormatter.compareDurations(queryValue, value);
+
+		return queryValue == value;
+	}
+
+	matchQuery (query: any): boolean | string {
+		if (query.search !== undefined)
+			return MAYBE;
+
+		if (query.custom !== undefined)
+			return MAYBE;
+
+		if (query.linkedTo !== undefined)
+			return this.matchLinkedToQuery(query);
+
+		if (query.conditions !== undefined)
+			return this.matchComplexQuery(query);
+
+		if (query.key !== undefined)
+			return this.matchSimpleQuery(this.fields[query.key], query);
+
+		if (!hasProperties(query))
+			return true;
+
+		throw new Error('queryMatcher: Unsupported query! Parsed?');
+	}
+
+	private matchLinkedToQuery (query) {
+		if (query.reverse)
+			return MAYBE;
+
+		let match;
+
+		if (query.linkedTo !== this.parentType)
+			match = false;
+		else
+			match = this.matchSimpleQuery(this.parentId, query.query);
+
+		if (match === MAYBE)
+			return MAYBE;
+
+		return query.not ? !match : match;
+	}
+
+	private matchComplexQuery (query) {
+		const conditions = query.conditions;
+
+		let result;
+		let terminal;
+
+		switch (query.operator) {
+			case 'AND':
+				result = true;
+				terminal = false;
+				break;
+			case 'OR':
+				result = false;
+				terminal = true;
+				break;
+			default:
+				throw new Error('queryMatcher: Unsupported operator');
+		}
+
+		for (const condition of conditions) {
+			const match = this.matchQuery(condition);
+
+			if (match === terminal)
+				return terminal;
+
+			if (match === MAYBE)
+				result = MAYBE;
+		}
+
+		return result;
+	}
+
+	private matchSimpleQuery (value, query) {
+		const key = query.key;
+		let queryValue = query.value;
+
+		if (!hasProperties(query)) // Could be linkedTo an empty object
+			return true;
+
+		if (value === undefined) {
+			console.warn('Required field', key, 'not found for', this.itemType);
+			return MAYBE;
+		}
+
+		if (queryValue === 'NOW')
+			queryValue = moment();
+
+		switch (query.comparator) {
+			case '=':
+				return this.compareValues(value, queryValue);
+			case '!=':
+				return !this.compareValues(value, queryValue);
+			case '<':
+				return value < queryValue;
+			case '<=':
+				return value <= queryValue;
+			case '>':
+				return value > queryValue;
+			case '>=':
+				return value >= queryValue;
+			case 'IN':
+				return inArray(value, queryValue);
+			case 'NOT IN':
+				return !inArray(value, queryValue);
+			default:
+				throw new Error('queryMatcher: Unsupported comparator: ' + query.comparator + ' in query ' + query);
+		}
+	}
+}

package/src/classes/QueryParser.ts

@@ -0,0 +1,209 @@
+import * as moment from 'moment';
+import { getFirstProperty, hasProperties } from "./Util";
+
+enum CONSTANTS {
+	OBJ = 0,
+	STR = 1,
+	SEP = ':'
+}
+
+export default class QueryParser {
+	query: any;
+	parameters: any;
+
+	constructor (query, parameters) {
+		this.query = query;
+		this.parameters = parameters;
+	}
+
+	private processValue (value) {
+		// algorithm is not important, as long as all arrays are sorted the same way
+		if (Array.isArray(value))
+			return value.slice().sort();
+
+		if (moment.isMoment(value))
+			return moment(value);
+
+		if (moment.isDuration(value))
+			return moment.duration(value);
+
+		return value;
+	}
+
+	private compareParsedQueries (a, b) {
+		if (a[CONSTANTS.STR] === b[CONSTANTS.STR])
+			return 0;
+
+		return a[CONSTANTS.STR] > b[CONSTANTS.STR] ? 1 : -1;
+	}
+
+	parse (query = this.query) {
+		if (query.linkedTo !== undefined)
+			return this.parseLinkedToQuery(
+				query.linkedTo,
+				query.query,
+				query.reverse,
+				query.not
+			);
+
+		if (query.not !== undefined)
+			throw new Error('queryParser: "Not" not supported');
+
+		if (query.custom !== undefined)
+			return this.parseCustomQuery(
+				query.custom,
+				query.parameters
+			);
+
+		if (query.search !== undefined)
+			return this.parseSearchQuery(query.search);
+
+		if (query.conditions !== undefined)
+			return this.parseComplexQuery(
+				query.conditions,
+				query.operator
+			);
+
+		if (query.key !== undefined)
+			return this.parseSimpleQuery(
+				query.key,
+				query.value,
+				query.comparator
+			);
+
+		if (!hasProperties(query))
+			return [{}, '{}'];
+
+		const key = getFirstProperty(query);
+
+		return this.parseSimpleQuery(key, query[key]);
+	}
+
+	private parseSearchQuery (value) {
+		value = this.formatValue(value);
+
+		return [
+			{search: value[CONSTANTS.OBJ]},
+			'[' + 'search' + CONSTANTS.SEP + value[CONSTANTS.STR] + ']'
+		];
+	}
+
+	private parseCustomQuery (custom, parameters) {
+		if (parameters === undefined)
+			return [
+				{custom: custom},
+				'[' + custom + ']'
+			];
+
+		const parsedParameters = this.parseCustomParameters(parameters);
+
+		return [
+			{custom: custom, parameters: parsedParameters[CONSTANTS.OBJ]},
+			'[' + custom + CONSTANTS.SEP + parsedParameters[CONSTANTS.STR] + ']'
+		];
+	}
+
+	private parseCustomParameters (parameters) {
+		const keys = Object.keys(parameters).sort();
+
+		const query = {};
+		let string = '';
+
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const value = this.formatValue(parameters[key]);
+
+			query[key] = value[CONSTANTS.OBJ];
+
+			if (i > 0)
+				string += CONSTANTS.SEP;
+
+			string += value[CONSTANTS.STR];
+		}
+
+		return [query, string];
+	}
+
+	private parseSimpleQuery (key, value, comparator?) {
+		value = this.formatValue(value);
+
+		if (comparator === undefined)
+			comparator = Array.isArray(value[CONSTANTS.OBJ]) ? 'IN' : '=';
+
+		return [
+			{key: key, value: value[CONSTANTS.OBJ], comparator: comparator},
+			'[' + comparator + CONSTANTS.SEP + key + CONSTANTS.SEP + value[CONSTANTS.STR] + ']'
+		];
+	}
+
+	private parseLinkedToQuery (linkedTo, query, reverse, not) {
+		if (query === undefined)
+			query = {};
+
+		if (reverse === undefined)
+			reverse = false;
+
+		if (not === undefined)
+			not = false;
+
+		const parsedQuery = this.parse(query);
+
+		return [
+			{linkedTo: linkedTo, query: parsedQuery[CONSTANTS.OBJ], reverse: reverse, not: not},
+			'[' + 'linkedTo' + CONSTANTS.SEP + linkedTo + CONSTANTS.SEP + parsedQuery[CONSTANTS.STR] + CONSTANTS.SEP + reverse + CONSTANTS.SEP + not + ']'
+		];
+	}
+
+	private parseComplexQuery (conditions, operator) {
+		if (operator === undefined)
+			operator = 'AND';
+		else
+			operator = operator.toUpperCase();
+
+		const parsedConditions = this.parseConditions(conditions);
+
+		return [
+			{conditions: parsedConditions[CONSTANTS.OBJ], operator: operator},
+			'[' + operator + parsedConditions[CONSTANTS.STR] + ']'
+		];
+	}
+
+	private parseConditions (conditions) {
+		let parsedConditions = [];
+		const query = [];
+		let string = '';
+
+		for (const condition of conditions)
+			parsedConditions.push(this.parse(condition));
+
+		parsedConditions = parsedConditions.sort(this.compareParsedQueries);
+
+		for (const parsedCondition of parsedConditions) {
+			query.push(parsedCondition[CONSTANTS.OBJ]);
+			string += parsedCondition[CONSTANTS.STR];
+		}
+
+		return [query, string];
+	}
+
+	private formatValue (value) {
+		let processedValue;
+
+		if (typeof value === 'string' && value.charAt(0) === '&') {
+			const key = value.substring(1);
+
+			value = this.parameters[key];
+
+			if (value === undefined)
+				throw new Error('queryParser: Undefined template parameter \'' + key + '\'');
+
+			processedValue = this.processValue(value);
+
+			return [processedValue, key + '>' + value];
+		}
+
+		processedValue = this.processValue(value);
+
+		return [processedValue, '' + processedValue];
+	}
+}

package/src/classes/QueryService.ts

@@ -0,0 +1,35 @@
+export default class QueryService {
+	constructor () {
+	}
+
+	addAndCondition (query, condition) {
+		if (query.conditions === undefined || query.operator === 'or')
+			return {conditions: [query, condition]};
+
+		// we have an 'and' condition
+		return {conditions: query.conditions.concat(condition)};
+	}
+
+	addOrCondition (query, condition) {
+		if (query.operator === 'or')
+			return {conditions: query.conditions.concat(condition)};
+
+		// we have an 'and' condition
+		return {conditions: [query, condition], operator: 'or'};
+	}
+
+	addParentCondition (query, parent) {
+		let linkedToQuery;
+
+		if (parent === null)
+			return query;
+
+		linkedToQuery = {linkedTo: parent.itemType, query: parent.itemId};
+
+		return query === null ? linkedToQuery : this.addAndCondition(query, linkedToQuery);
+	}
+
+	createNotIn (idArray) {
+		return {comparator: 'NOT IN', key: 'id', value: idArray};
+	}
+}

package/src/classes/RequestColumnExpansion.ts

@@ -0,0 +1,31 @@
+import ColumnUtil from "./ColumnUtil";
+
+export default class RequestColumnExpansion {
+	private columns = {};
+	private columnInfoIdMap = {};
+
+	constructor (
+		private columnUtil: ColumnUtil
+	) {
+	}
+
+	expand (columnInfo) {
+		if (this.columnInfoIdMap[columnInfo.id])
+			return;
+
+		const itemType = columnInfo.itemType;
+
+		if (this.columns[itemType] === undefined)
+			this.columns[itemType] = [];
+
+		this.columns[itemType] = this.columnUtil
+			.mergeRequestColumns(this.columns[itemType], columnInfo.request)
+			.merged;
+
+		this.columnInfoIdMap[columnInfo.id] = true;
+	}
+
+	get () {
+		return this.columns;
+	}
+}

package/src/classes/ResourceCache.ts

@@ -0,0 +1,289 @@
+import ChangesProcessorFactory from "../factories/ChangesProcessorFactory";
+import CollectionCacheFactory from "../factories/CollectionCacheFactory";
+import CollectionResourceFactory from "../factories/CollectionResourceFactory";
+import ItemCacheFactory from "../factories/ItemCacheFactory";
+import ItemResourceFactory from "../factories/ItemResourceFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import CollectionResource from "../models/CollectionResource";
+import ItemEntry from "../models/ItemEntry";
+import ItemResource from "../models/ItemResource";
+import CollectionCache from "./CollectionCache";
+import CollectionHandler from "./CollectionHandler";
+import ColumnHandler from "./ColumnHandler";
+import ItemCache from './ItemCache';
+import ItemEntryService from './ItemEntryService';
+import ItemHandler from "./ItemHandler";
+import ItemResourceService from './ItemResourceService';
+import LockService from "./LockService";
+import PromiseService from "./PromiseService";
+import { extend } from './Util';
+
+export default class ResourceCache {
+	collections: CollectionCache;
+	deferredCollections: CollectionCache;
+	items: ItemCache;
+	collectionOptions = {};
+	tabRequestParameters = {};
+	callbacks = {onBeforeSave: {}, onSaveSuccess: {}, onSaveWithoutClosing: {}};
+
+	changesInterval: null | number;
+	_hasChanges = false;
+	rootItem: ItemEntry;
+
+	constructor (
+		private apiRequestService: ApiRequestServiceInterface,
+		private errorHandler: ErrorHandlerInterface,
+		private itemHandler: ItemHandler,
+		private collectionHandler: CollectionHandler,
+		private columnHandler: ColumnHandler,
+		private lockService: LockService,
+		private itemResourceFactory: ItemResourceFactory,
+		private collectionCacheFactory: CollectionCacheFactory,
+		private changesProcessorFactory: ChangesProcessorFactory,
+		private itemCacheFactory: ItemCacheFactory,
+		private collectionResourceFactory: CollectionResourceFactory,
+		private itemEntryService: ItemEntryService,
+		private itemResourceService: ItemResourceService,
+		private promiseService: PromiseService
+	) {
+		this.collections = this.collectionCacheFactory.construct();
+		this.deferredCollections = this.collectionCacheFactory.construct();
+		this.items = this.itemCacheFactory.construct();
+	}
+
+	addSingleItem (itemEntry: ItemEntry, options, isRoot) {
+		if (isRoot)
+			this.rootItem = itemEntry;
+
+		if (!this.items.contains(itemEntry.itemType, itemEntry.itemId))
+			this.items.add(itemEntry);
+
+		options = this.itemResourceService.processOptions(options);
+		options.onDeactivate = this.clearItem;
+
+		return this.itemResourceFactory.construct(itemEntry, options);
+	}
+
+	addCollection (collectionEntry: CollectionEntry, resourceOptions) {
+		if (!this.collections.contains(collectionEntry)) {
+			this.collections.add(collectionEntry);
+		}
+
+		const collectionEntryId = collectionEntry.id;
+
+		if (this.collectionOptions[collectionEntryId] === undefined)
+			this.collectionOptions[collectionEntryId] = {
+				edit: resourceOptions.editCollection,
+				editItems: resourceOptions.editItems
+			};
+		else {
+			const collectionOptionsEntry = this.collectionOptions[collectionEntryId];
+
+			collectionOptionsEntry.edit = collectionOptionsEntry.edit || resourceOptions.editCollection;
+			collectionOptionsEntry.editItems = collectionOptionsEntry.editItems || resourceOptions.editItems;
+		}
+
+		resourceOptions.onDeactivateItem = this.clearItem;
+		resourceOptions.onDeactivateCollection = this.clearCollection;
+
+		return this.collectionResourceFactory.construct(collectionEntry, resourceOptions);
+	}
+
+	clearCollection (collectionResource: CollectionResource) {
+		const collectionEntry: CollectionEntry = collectionResource.entry;
+
+		this.collections.clear(collectionEntry);
+		collectionEntry.clearResources();
+	}
+
+	clearItem (itemResource: ItemResource) {
+		const itemEntry: ItemEntry = itemResource.entry;
+
+		this.items.clear(itemEntry);
+		this.itemEntryService.clearResources(itemEntry);
+	}
+
+	clearResources (isSubTabChange = false) {
+		this.items.forEach(this.itemEntryService.clearResources);
+
+		this.collections.forEach(collectionEntry => {
+				collectionEntry.clearResources(isSubTabChange);
+			}
+		);
+
+		// TODO: remove this condition once crew and transport are no longer loaded in seperate grid instances in the project planner grid
+		if (!isSubTabChange)
+			this.collections.clear();
+	}
+
+	updateSingleItems (conversionMap) {
+		for (const itemType in conversionMap) {
+			for (const oldItemId in conversionMap[itemType]) {
+				const itemEntry = this.items.get(itemType, oldItemId);
+
+				if (itemEntry === undefined)
+					continue;
+
+				this.items.updateItemId(itemEntry, oldItemId);
+			}
+		}
+	}
+
+	// resources will be cleared later (clear function)
+	revertChanges () {
+		this.items.forEach(this.itemEntryService.resetModified);
+		this.collections.forEach(this.resetCollection);
+	}
+
+	resetCollection (collectionEntry: CollectionEntry) {
+		const options = this.collectionOptions[collectionEntry.id];
+
+		if (options.edit)
+			collectionEntry.revertChanges();
+
+		if (!options.editItems)
+			return;
+
+		// these are edit resources (editItems)
+		for (const collectionItem of collectionEntry.items)
+			this.itemEntryService.resetModified(collectionItem);
+	}
+
+	hasChanges () {
+		if (!this._hasChanges)
+			this._hasChanges = this.detectChanges();
+
+		return this._hasChanges;
+	}
+
+	detectChanges () {
+		if (this.items.some(this.itemEntryService.hasChanges))
+			return true;
+
+		return this.collections.some((collectionEntry: CollectionEntry) => {
+			this.collectionHasChanges(collectionEntry);
+		});
+	}
+
+	collectionHasChanges (collectionEntry: CollectionEntry) {
+		const options = this.collectionOptions[collectionEntry.id];
+
+		if (options.edit && (collectionEntry.hasAddedItems() || collectionEntry.hasRemovedItems()))
+			return true;
+
+		return options.editItems && collectionEntry.hasUpdatedItems();
+	}
+
+	isLockable () {
+		if (this.rootItem === undefined)
+			return false;
+
+		return this.itemEntryService.isLockable(this.rootItem);
+	}
+
+	save (closeTab = false, parameters, breakUpByParent, onAfterCreateCallback) {
+		return (this.isLockable() ? this.lockService.fetchLock(this.rootItem) : this.promiseService.when()).then(
+			lockToken => {
+				return this.executeCallbacks('onBeforeSave', closeTab);
+			},
+			this.errorHandler.reject
+		).then(
+			() => {
+				const requestParameters = extend({}, this.tabRequestParameters, parameters);
+
+				this.tabRequestParameters = {};
+
+				return this.changesProcessorFactory.construct().execute(
+					this.items.toArray(),
+					this.collections.toArray(),
+					breakUpByParent,
+					requestParameters,
+					this.collectionOptions,
+					onAfterCreateCallback
+				);
+			},
+			this.errorHandler.reject
+		).then(conversionMap => {
+				if (this.isLockable())
+					this.lockService.clearLock(this.rootItem);
+
+				this._hasChanges = false;
+
+				if (!closeTab)
+					this.updateSingleItems(conversionMap);
+
+				return this.executeCallbacks('onSaveSuccess', conversionMap).then(
+					() => {
+						if (!closeTab)
+							this.executeCallbacks('onSaveWithoutClosing', conversionMap);
+
+						return conversionMap;
+					},
+					this.errorHandler.reject
+				);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	executeCallbacks (event, callbackParameter) {
+		const result = {};
+
+		for (const key in this.callbacks[event])
+			result[key] = this.callbacks[event][key](callbackParameter);
+
+		return this.promiseService.all(result);
+	}
+
+	enableChangesWatcher () {
+		if (this.changesInterval !== null) {
+			console.warn('Changes watcher already running!', this);
+			this.disableChangesWatcher();
+		}
+
+		this.changesInterval = setInterval(
+			() => {
+				if (!this.hasChanges())
+					return;
+
+				this.disableChangesWatcher();
+
+				if (this.isLockable())
+					this.lockService.fetchLock(this.rootItem);
+			},
+			3000
+		);
+	}
+
+	/**
+	 * @deprecated
+	 */
+	enableWatcher () {
+		this.enableChangesWatcher();
+	}
+
+	disableChangesWatcher () {
+		clearInterval(this.changesInterval);
+		this.changesInterval = null;
+	}
+
+	/**
+	 * @deprecated
+	 */
+	disableWatcher () {
+		this.disableChangesWatcher();
+	}
+
+	/**
+	 * @deprecated
+	 */
+	registerCallback (event: string, key: string, callback) {
+		this.callbacks[event][key] = callback;
+
+		return () => {
+			delete this.callbacks[event][key];
+		};
+	}
+}