@rentman/rm-core 1.0.0

package/src/classes/ColumnUtil.ts

@@ -0,0 +1,589 @@
+import * as moment from 'moment';
+import { COLUMN_SEPERATOR, RENDER_AS_SEPERATOR } from '../constants';
+
+import { copy, extend, getFirstProperty, isDefined } from './Util';
+
+export default class ColumnUtil {
+	constructor () {
+	}
+	
+	getColumnPath (columns, renderAs) {
+		let seperator = '';
+		let result = '';
+
+		for (const column of columns) {
+			result += seperator + column.id;
+			seperator = COLUMN_SEPERATOR;
+		}
+
+		if (renderAs !== null)
+			result += RENDER_AS_SEPERATOR + renderAs;
+
+		return result;
+	}
+
+	getDateFormatOptions (columnType) {
+		const now = moment();
+
+		const formats = {
+			'J-M-Y': now.format('DD-MM-YYYY'),
+			'J-M': now.format('DD-MM'),
+			'j+F+Y': now.format('D MMM YYYY'),
+			'D+j+F+Y': now.format('dddd D MMM YYYY'),
+			'F': now.format('MMM'),
+			'f': now.format('MMMM'),
+			'D': now.format('dddd'),
+			'd': now.format('ddd')
+		};
+
+		if (columnType === 'datetime')
+			extend(formats, {
+				'J-M-Y+H:i': now.format('DD-MM-YYYY HH:mm'),
+				'J-M+H:i': now.format('DD-MM HH:mm'),
+				'j+F+Y+H:i': now.format('DD MMMM Y HH:mm'),
+				'D+j+F+Y+H:i': now.format('dddd DD MMM Y HH:mm'),
+				'H:i': now.format('HH:mm'),
+			});
+
+		return formats;
+	}
+
+	isFloatColumn (column) {
+		switch (column.type) {
+			case 'double': // floating point types
+			case 'volume':
+			case 'weight':
+			case 'distance':
+			case 'dimension':
+			case 'power':
+			case 'current':
+			case 'price':
+			case 'percentage':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isIntColumn (column) {
+		switch (column.type) {
+			case 'int': // integer types
+			case 'number':
+			case 'quantity':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isNumberColumn (column) {
+		return this.isFloatColumn(column) || this.isIntColumn(column);
+	}
+
+	isCustomColumn (column) {
+		return column.fieldtype === 'customfield';
+	}
+
+	isItemColumn (column, includeId = true) {
+		switch (column.type) {
+			case 'id':
+				return includeId;
+			case 'item':
+			case 'child':
+			case 'sibling':
+			case 'link':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isDateColumn (column) {
+		switch (column.type) {
+			case 'datetime':
+			case 'date':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isRenderedColumn (column) {
+		switch (column.type) {
+			case 'datetime':
+			case 'date':
+			case 'duration':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isFilteredColumn (column) {
+		// ugly hack :-(
+		if (column.id === 'staffel')
+			return true;
+
+		if (column.generator !== undefined)
+			return true;
+
+		switch (column.type) {
+			case 'price':
+			case 'bool':
+			case 'enum':
+			case 'volume':
+			case 'weight':
+			case 'distance':
+			case 'dimension':
+			case 'quantity':
+			case 'email':
+			case 'url':
+			case 'datetime':
+			case 'date':
+			case 'time':
+			case 'duration':
+			case 'html':
+			case 'textreplace':
+			case 'longtext':
+			case 'percentage':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isFormattedColumn (column) {
+		switch (column.type) {
+			case 'datetime':
+			case 'date':
+			case 'time':
+			case 'duration':
+			case 'color':
+			case 'json':
+			case 'number':
+			case 'filesize':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	isSelectableColumn (column) {
+		switch (column.type) {
+			case 'blob':
+			case 'coordinate':
+			case 'forceupdate':
+			case 'id':
+			case 'json':
+			case 'order':
+			case 'parentid':
+			case 'parenttype':
+			case 'password':
+			case 'token':
+				return false;
+		}
+
+		return true;
+	}
+
+	hasLocationProperty (column, location) {
+		// tslint:disable:no-bitwise
+		return (location & column.location) !== 0;
+	}
+
+	isEditableColumn (column) {
+		if (column.readOnly)
+			return false;
+
+		switch (column.type) {
+			case 'date':
+			case 'datetime':
+			case 'duration':
+				return false;
+		}
+
+		return true;
+	}
+
+	isSearchableColumn (column) {
+		switch (column.type) {
+			case 'email':
+			case 'phone':
+			case 'text':
+			case 'longtext':
+			case 'html':
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	getDefaultWeight (column) {
+		// 			console.log('getDefaultWeight', column);
+
+		switch (column.type) {
+			case 'double':
+			case 'price':
+			case 'bool':
+			case 'int':
+			case 'percentage':
+			case 'color':
+			case 'number':
+			case 'power':
+			case 'current':
+				return 0.5;
+
+			case 'url':
+			case 'enum':
+			case 'email':
+			case 'text':
+			case 'item':
+			case 'link':
+				return 1.5;
+
+			case 'longtext':
+			case 'html':
+			case 'textreplace':
+				return 2;
+
+			case 'date':
+			case 'datetime':
+			case 'time':
+			case 'duration':
+				return 1;
+			default:
+				return 1;
+		}
+	}
+
+	getComparators (column) {
+		switch (column.type) {
+			case 'dimension':
+			case 'weight':
+			case 'price':
+				return ['=', '>', '<'];
+			case 'date':
+			case 'datetime':
+			case 'time':
+			case 'duration':
+				return ['>', '<'];
+			default:
+				return ['=', '!='];
+		}
+	}
+
+	// returns whether the first column set is a subset of the second
+	isColumnSubset (first, second, secondTrue) {
+		if (first === true) // === operator needed here
+			return secondTrue;
+
+		// when secondTrue is the case we need to check for derived columns
+		for (const column of first) {
+			if (!this.containsColumn(column, second))
+				return false;
+		}
+
+		return true;
+	}
+
+	containsColumn (requestColumn, destination) {
+		const column = this.parseRequestColumn(requestColumn);
+		const columnIndex = this.findColumn(column.id, destination);
+
+		if (columnIndex === -1)
+			return false;
+
+		if (column.children.length === 0)
+			return true;
+
+		if (typeof destination[columnIndex] === 'string')
+			return false;
+
+		for (const childColumn of column.children) {
+			if (
+				!this.containsColumn(
+					childColumn,
+					destination[columnIndex][column.id]
+				)
+			)
+				return false;
+		}
+
+		return true;
+	}
+
+	responseColumnsAvailable (itemType, requestColumns, responseColumnMap) {
+		for (const requestColumn of requestColumns) {
+			const parsedColumn = this.parseRequestColumn(requestColumn);
+			const children = parsedColumn.children;
+			const responseColumns = responseColumnMap[itemType];
+			let responseColumn;
+
+			if (responseColumns === undefined)
+				return false;
+
+			responseColumn = responseColumns[parsedColumn.id];
+
+			if (responseColumn === undefined)
+				return false;
+
+			if (children.length > 0 && !this.responseColumnsAvailable(responseColumn.itemType, children, responseColumnMap))
+				return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Difference: columns that are in second, but not in first
+	 * @param {Array} first
+	 * @param {Array} second
+	 * @returns {Object} An object containing 'merged' and 'difference' properties
+	 */
+	mergeRequestColumns (first, second) {
+		if (first === true) // === operator needed here
+			return {merged: true, difference: []};
+
+		if (second === true)
+			return {merged: true, difference: true};
+
+		const merged = copy(first);
+		const difference = [];
+
+		for (const column of second) {
+			const addedColumn = this.mergeRequestColumn(column, merged);
+
+			if (addedColumn !== null)
+				difference.push(addedColumn);
+		}
+
+		return {merged: merged, difference: difference};
+	}
+
+	mergeRequestColumn (requestColumn, destination) {
+		const column = this.parseRequestColumn(requestColumn);
+		const columnIndex = this.findColumn(column.id, destination);
+
+		if (columnIndex === -1) {
+			destination.push(requestColumn);
+			return requestColumn;
+		}
+
+		if (column.children.length === 0)
+			return null;
+
+		if (typeof destination[columnIndex] === 'string') {
+			destination[columnIndex] = {
+				[column.id]: []
+			};
+		}
+
+		const addedColumns = [];
+
+		for (const childColumn of column.children) {
+			const addedColumn = this.mergeRequestColumn(
+				childColumn,
+				destination[columnIndex][column.id]
+			);
+
+			if (addedColumn !== null)
+				addedColumns.push(addedColumn);
+		}
+
+		if (addedColumns.length === 0)
+			return null;
+
+		return {
+			[column.id]: addedColumns
+		};
+	}
+
+	parseRequestColumn (requestColumn) {
+		const isLeaf = typeof requestColumn === 'string';
+		const columnId = isLeaf ? requestColumn : getFirstProperty(requestColumn);
+
+		return {
+			id: columnId,
+			children: isLeaf ? [] : requestColumn[columnId]
+		};
+	}
+
+	/**
+	 * Merges two sets of response columns.
+	 * @param {object} first
+	 * @param {object} second
+	 * @returns {object} An object containing a 'merged' and a 'difference' property.
+	 */
+	mergeResponseColumns (first, second) {
+		const merged = {};
+		const difference = {};
+
+		for (const itemType in first) {
+			if (second[itemType] === undefined) {
+				merged[itemType] = first[itemType];
+
+				continue;
+			}
+
+			const mergeResult = this.mergeResponseColumnMap(
+				first[itemType],
+				second[itemType]
+			);
+
+			merged[itemType] = mergeResult.merged;
+			difference[itemType] = mergeResult.difference;
+		}
+
+		for (const itemType in second) {
+			if (first[itemType] === undefined) {
+				merged[itemType] = second[itemType];
+				difference[itemType] = second[itemType];
+			}
+		}
+
+		return {merged: merged, difference: difference};
+	}
+
+	/**
+	 * @param {array} first
+	 * @param {array} second
+	 * @returns {object} difference: the columns that are in second, but not in first.
+	 */
+	mergeResponseColumnMap (first, second) {
+		const merged = {};
+		const difference = {};
+
+		for (const columnId in first)
+			merged[columnId] = first[columnId];
+
+		for (const columnId in second) {
+			if (isDefined(first[columnId]))
+				continue;
+
+			merged[columnId] = second[columnId];
+			difference[columnId] = second[columnId];
+		}
+
+		return {merged: merged, difference: difference};
+	}
+
+	isLocalColumnId (columnId) {
+		return columnId.substring(0, 2) === '__';
+	}
+
+	processConfigColumns (columns) {
+		const request = [];
+
+		for (const column of columns) {
+			if (this.isLocalColumnId(column))
+				continue;
+
+			this.processConfigColumn(this.parseConfigColumn(column), request);
+		}
+
+		return request;
+	}
+
+	processLocalConfigColumns (configColumns, localColumns, remoteColumnCallback, localColumnCallback) {
+		const localColumnMap = {};
+
+		for (const localColumn of localColumns)
+			localColumnMap[localColumn.id] = localColumn;
+
+		for (const configId of configColumns) {
+			const parsedConfigId = configId.split(RENDER_AS_SEPERATOR);
+			const columnId = parsedConfigId[0];
+
+			if (!this.isLocalColumnId(columnId)) {
+				remoteColumnCallback(configId, columnId, parsedConfigId[1]);
+
+				continue;
+			}
+
+			// column might not be available in localColumns
+			if (localColumnMap[columnId] === undefined)
+				continue;
+
+			localColumnCallback(configId, localColumnMap[columnId]);
+			delete localColumnMap[columnId];
+		}
+	}
+
+	consolidateColumns (configColumns, localColumns, addRequestColumns) {
+		const filteredLocalColumns = [];
+		let requestColumns = copy(addRequestColumns);
+
+		this.processLocalConfigColumns(
+			configColumns,
+			localColumns,
+			(configId, columnId) => {
+				this.processConfigColumn(columnId.split(COLUMN_SEPERATOR), requestColumns);
+			},
+			(configId, localColumn) => {
+				filteredLocalColumns.push(localColumn);
+				requestColumns = this.mergeRequestColumns(
+					requestColumns,
+					localColumn.valueOptions.requestColumns
+				).merged;
+			}
+		);
+
+		return {request: requestColumns, local: filteredLocalColumns};
+	}
+
+	parseConfigColumn (column) {
+		return column.split(RENDER_AS_SEPERATOR)[0].split(COLUMN_SEPERATOR);
+	}
+
+	processConfigColumn (columnArray, destination) {
+		const columnId = columnArray[0];
+		const isLeaf = columnArray.length === 1;
+
+		if (isLeaf) {
+			if (destination.indexOf(columnId) === -1)
+				destination.push(columnId);
+
+			return;
+		}
+
+		let columnIndex = this.findColumnObject(columnId, destination);
+
+		if (columnIndex === -1) {
+			columnIndex = destination.push({
+				[columnId]: []
+			}) - 1;
+		}
+
+		this.processConfigColumn(
+			columnArray.slice(1),
+			destination[columnIndex][columnId]
+		);
+	}
+
+	findColumnObject (columnId, array) {
+		for (let i = 0; i < array.length; i++) {
+			if (getFirstProperty(array[i]) === columnId)
+				return i;
+		}
+
+		return -1;
+	}
+
+	findColumn (columnId, array) {
+		for (let i = 0; i < array.length; i++) {
+			const column = array[i];
+
+			if (typeof column === 'string') {
+				if (column === columnId)
+					return i;
+
+				continue;
+			}
+
+			if (getFirstProperty(column) === columnId)
+				return i;
+		}
+
+		return -1;
+	}
+}