@softwear/latestcollectioncore 1.0.76 → 1.0.78

package/dist/articleStatus.d.ts

@@ -0,0 +1,79 @@
+import { TransactionI, RaGI, HrTimeframeI, TimeGranularityE, SkuI } from './types';
+/**
+ * The propFunction for FiltreX needs some data that can't be passed as parameters. That's why the 'globalsRelations' variable is needed.
+ * TODO: Functional: Experiment with curried functions
+ */
+declare function propFunction(propertyName: string, getPropertyName: Function, obj: Record<string, any>): any;
+declare function whichShardsToProcess(dateRange: any, granularity: 'year' | 'month'): any[];
+/**
+ *
+ * @param {*} v: a vector
+ * @param {*} timeFrame: nr miliseconds in timeframe
+ *
+ * Calculate all derived columns on a given vector.
+ */
+declare function postAgg(v: any, timeFrame: number): void;
+declare function getTimeGrouper(groupers: string[]): TimeGranularityE | undefined;
+declare function runQuery(timeframe: HrTimeframeI, rawAggregations: RaGI, beginStock: boolean, transactions: TransactionI[], selectedGroupsValues: string[], skus: SkuI[], warehouses: any[], subtotalsForOuterGrouper: boolean, computedFilter: string, parentGroupTotals: boolean): RaGI;
+declare const _default: {
+    getDateRangeFromPicker: (inputDates: string[]) => HrTimeframeI;
+    getTimeGrouper: typeof getTimeGrouper;
+    filtrexOptions: {
+        extraFunctions: {
+            lower: (s: string) => string;
+            upper: (s: string) => string;
+        };
+        customProp: typeof propFunction;
+    };
+    postAgg: typeof postAgg;
+    runQuery: typeof runQuery;
+    whichShardsToProcess: typeof whichShardsToProcess;
+    AMOUNT_CHANGE: number;
+    AMOUNT_CONSIGNMENT: number;
+    AMOUNT_END_SHELF_STOCK: number;
+    AMOUNT_END_STOCK: number;
+    AMOUNT_MINIMUM_STOCK: number;
+    AMOUNT_PO: number;
+    AMOUNT_PO_COMPLETE: number;
+    AMOUNT_RECIEVED: number;
+    AMOUNT_RETURN: number;
+    AMOUNT_REVALUATE: number;
+    AMOUNT_SHELF_STOCK: number;
+    AMOUNT_SOLD: number;
+    AMOUNT_SOLD_DISCOUNT: number;
+    AMOUNT_SOLD_EXCL: number;
+    AMOUNT_SOLD_MAX: number;
+    AMOUNT_STOCK: number;
+    AMOUNT_TRANSIT: number;
+    AMOUNT_TURNOVER_VELOCITY: number;
+    COSTPRICE_CONSIGNMENT: number;
+    COSTPRICE_SOLD: number;
+    MARGIN: number;
+    MAX_RECIEVE_TIMESTAMP: number;
+    PROFIT: number;
+    PROFITABILITY: number;
+    QTY_AVG_STOCK: number;
+    QTY_CHANGE: number;
+    QTY_CONSIGNMENT: number;
+    QTY_END_SHELF_STOCK: number;
+    QTY_END_STOCK: number;
+    QTY_MINIMUM_STOCK: number;
+    QTY_PO: number;
+    QTY_PO_COMPLETE: number;
+    QTY_RECIEVED: number;
+    QTY_RETURN: number;
+    QTY_SHELF_STOCK: number;
+    QTY_SOLD: number;
+    QTY_SOLD_BEFORE_RETURNS: number;
+    QTY_STOCK: number;
+    QTY_TRANSACTION: number;
+    QTY_TRANSIT: number;
+    QTY_TURNOVER_VELOCITY: number;
+    RETURN_PERCENTAGE: number;
+    ROI: number;
+    SELLOUT_PERCENTAGE: number;
+    STOCKAMOUNT_TIME_PRODUCT: number;
+    STOCK_TIME_PRODUCT: number;
+    VALUE_AVG_STOCK: number;
+};
+export default _default;

package/dist/articleStatus.js

@@ -0,0 +1,414 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const filtrex_1 = require("filtrex");
+const types_1 = require("./types");
+const transaction_1 = __importDefault(require("./transaction"));
+const date_fns_1 = require("date-fns");
+// fields in Vector
+const { QTY_TRANSACTION, QTY_STOCK, AMOUNT_STOCK, QTY_SHELF_STOCK, AMOUNT_SHELF_STOCK, AMOUNT_REVALUATE, QTY_RECIEVED, AMOUNT_RECIEVED, QTY_SOLD, AMOUNT_SOLD, AMOUNT_SOLD_EXCL, COSTPRICE_SOLD, QTY_CHANGE, AMOUNT_CHANGE, QTY_TRANSIT, AMOUNT_TRANSIT, QTY_PO, AMOUNT_PO, QTY_PO_COMPLETE, AMOUNT_PO_COMPLETE, QTY_MINIMUM_STOCK, AMOUNT_MINIMUM_STOCK, QTY_CONSIGNMENT, AMOUNT_CONSIGNMENT, COSTPRICE_CONSIGNMENT, } = transaction_1.default.transactionVector;
+// DERIVED FIELDS
+const AMOUNT_SOLD_MAX = 25;
+const AMOUNT_SOLD_DISCOUNT = 26;
+const MAX_RECIEVE_TIMESTAMP = 27;
+const STOCK_TIME_PRODUCT = 28;
+const STOCKAMOUNT_TIME_PRODUCT = 29;
+const QTY_RETURN = 30;
+const AMOUNT_RETURN = 31;
+// Vector length to allocate for aggregation
+const VECTOR_LENGTH = 32;
+// POST AGGREGATION COLUMNS
+const SELLOUT_PERCENTAGE = 32;
+const ROI = 33;
+const QTY_AVG_STOCK = 34;
+const VALUE_AVG_STOCK = 35;
+const QTY_TURNOVER_VELOCITY = 36;
+const AMOUNT_TURNOVER_VELOCITY = 37;
+const PROFITABILITY = 38;
+const MARGIN = 39;
+const PROFIT = 40;
+const QTY_END_SHELF_STOCK = 41;
+const AMOUNT_END_SHELF_STOCK = 42;
+const QTY_END_STOCK = 43;
+const AMOUNT_END_STOCK = 44;
+const RETURN_PERCENTAGE = 45;
+const QTY_SOLD_BEFORE_RETURNS = 46;
+const BEGIN_STOCK_VECTOR_START = QTY_STOCK;
+const BEGIN_STOCK_VECTOR_END = AMOUNT_SHELF_STOCK + 1;
+const msYear = 24 * 3600 * 365 * 1000;
+const globalJoinableTables = { sku: 'ean', wh: 'wh', transaction: 'row' }; // defines the keys we can join on
+/**
+ * Global variables
+ */
+let globalRelations = {}; // holds the joined tables
+let globalNrAggegationExpressions = 0; // tracks the # aggregations rows so we can quit computing if it grows out of bounds
+/**
+ * The propFunction for FiltreX needs some data that can't be passed as parameters. That's why the 'globalsRelations' variable is needed.
+ * TODO: Functional: Experiment with curried functions
+ */
+function propFunction(propertyName, getPropertyName, obj) {
+    var _a, _b;
+    const positionOfDot = propertyName.indexOf('.');
+    if (positionOfDot < 0)
+        return getPropertyName(propertyName);
+    const table = propertyName.substring(0, positionOfDot);
+    const field = propertyName.substring(positionOfDot + 1);
+    if (table == 'transaction')
+        return getPropertyName(field);
+    return ((_b = (_a = globalRelations[table]) === null || _a === void 0 ? void 0 : _a[obj[globalJoinableTables[table]]]) === null || _b === void 0 ? void 0 : _b[field]) || '~ ?';
+}
+const lower = (s) => s.toLowerCase();
+const upper = (s) => s.toUpperCase();
+const filtrexOptions = {
+    extraFunctions: { lower, upper },
+    customProp: propFunction,
+};
+// This is how the actual joining of 2 vectors happens
+function addVectors(targetVector, otherVector, begin, end) {
+    for (let i = begin; i < end; i++)
+        targetVector[i] += otherVector[i] || 0;
+}
+// This function takes a transaction and adds it to the aggregations
+function addTransactionToAggregations(beginTimestamp, endTimestamp, aggregateKey, rawAggregations, transaction, maxRows) {
+    let aggregateVector = rawAggregations[aggregateKey];
+    if (globalNrAggegationExpressions >= maxRows)
+        return;
+    if (!aggregateVector) {
+        globalNrAggegationExpressions++;
+        aggregateVector = new Float64Array(VECTOR_LENGTH);
+        rawAggregations[aggregateKey] = aggregateVector;
+    }
+    const vector = transaction.vector;
+    if (transaction.type == '1' && transaction.time > aggregateVector[MAX_RECIEVE_TIMESTAMP])
+        aggregateVector[MAX_RECIEVE_TIMESTAMP] = transaction.time;
+    if (transaction.time <= beginTimestamp)
+        return addVectors(aggregateVector, vector, BEGIN_STOCK_VECTOR_START, BEGIN_STOCK_VECTOR_END);
+    if (transaction.time > endTimestamp)
+        return;
+    addVectors(aggregateVector, vector, BEGIN_STOCK_VECTOR_END, vector.length);
+    // Calculate derived fields
+    aggregateVector[QTY_RETURN] += vector[QTY_SOLD] < 0 ? vector[QTY_SOLD] : 0;
+    aggregateVector[AMOUNT_RETURN] += vector[AMOUNT_SOLD_EXCL] < 0 ? vector[AMOUNT_SOLD_EXCL] : 0;
+    aggregateVector[STOCK_TIME_PRODUCT] +=
+        (vector[QTY_RECIEVED] || 0 + vector[QTY_TRANSIT] || 0 + vector[QTY_CHANGE] || 0 - vector[QTY_SOLD] || 0) * (endTimestamp - transaction.time);
+    aggregateVector[STOCKAMOUNT_TIME_PRODUCT] +=
+        (vector[AMOUNT_RECIEVED] || 0 + vector[AMOUNT_TRANSIT] || 0 + vector[AMOUNT_CHANGE] || 0 - vector[COSTPRICE_SOLD] || 0) * (endTimestamp - transaction.time);
+}
+function buildAggregationEvaluator(aggregationExpression) {
+    return (0, filtrex_1.compileExpression)(aggregationExpression, filtrexOptions);
+}
+function prepareSubTotalAggKey(aggKey) {
+    return aggKey.split('\t').slice(0, -1).join('\t').concat(' Σ');
+}
+/*
+ * A factory function that returns a function that can be used to aggregate transactions
+ * The factory function is called once for each aggregationExpression
+ * @param {Object} options
+ *
+ * @param {number} options.beginTimestamp - The begin of the time frame UNIX timestamp
+ * @param {number} options.endTimestamp - The end of the time frame UNIX timestamp
+ *
+ * @param {string} options.filterExpression - The FiltreX preprocessed filter expression for: brand, collection, warehouse and articleGroup
+ * Example: sku.brand in ("Gabor") and sku.collection not in ("21summer")
+ *
+ * @param {string} options.aggregationExpression - The aggregation expression that contains the aggregateKey
+ * Example: sku.brand+"	"+sku.collection+"	"+sku.articleGroup+"	"+sku.articleCodeSupplier
+ *
+ * @param {Object} options.rawAggregations - The raw aggregations object where keys are the aggregateKeys and values are the Float64Array vectors
+ *
+ * @param {number} options.maxRows - The maximum number of rows to aggregate
+ * @param {boolean} options.totals - Whether to aggregate totals
+ * @param {boolean} options.subtotalsForOuterGrouper - Whether to aggregate single subtotals
+ *
+ * @returns {Function} - The aggregator function
+ */
+function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregationExpression, rawAggregations, maxRows, totals, subtotalsForOuterGrouper, parentGroupTotals, }) {
+    const filterExpressionCache = {};
+    let filter;
+    let filterDependencyEvaluator;
+    if (filterExpression) {
+        filter = (0, filtrex_1.compileExpression)(filterExpression, filtrexOptions);
+        // Maintain a cache of evaluated filterExpressions
+        // The granularity of the cache is determined by the joined tables in the filterExpression
+        const filterGranularity = Object.entries(globalJoinableTables)
+            .filter((join) => filterExpression.includes(join[0] + '.'))
+            .map((join) => join[1]);
+        filterDependencyEvaluator = (0, filtrex_1.compileExpression)(filterGranularity.join('+'));
+    }
+    const aggregationEvaluator = buildAggregationEvaluator(aggregationExpression);
+    // Maintain a cache of evaluated aggregationExpressions
+    // The granularity of the cache is determined by the joined tables in the aggregationExpression
+    const aggregationExpressionCache = {};
+    const aggregationGranularity = Object.entries(globalJoinableTables)
+        .filter((join) => aggregationExpression.includes(join[0] + '.'))
+        .map((join) => join[1]);
+    let aggregationDependencyExpression = aggregationGranularity.join('+');
+    if (!aggregationDependencyExpression)
+        aggregationDependencyExpression = '"N.A."';
+    const aggregationDependencyEvaluator = (0, filtrex_1.compileExpression)(aggregationDependencyExpression);
+    return function (transaction) {
+        if (filter) {
+            const filterDependency = filterDependencyEvaluator(transaction);
+            const filterExpression = filterExpressionCache[filterDependency];
+            if (filterExpression == -1)
+                return;
+            if (!filterExpression) {
+                filterExpressionCache[filterDependency] = filter(transaction) ? 1 : -1;
+                if (filterExpressionCache[filterDependency] == -1)
+                    return;
+            }
+        }
+        const aggregationDependency = aggregationDependencyEvaluator(transaction);
+        let aggregateKey = aggregationExpressionCache[aggregationDependency];
+        if (!aggregateKey) {
+            aggregateKey = aggregationEvaluator(transaction);
+            aggregationExpressionCache[aggregationDependency] = aggregateKey;
+        }
+        // Prepare joined values for derived fields
+        if (transaction.type == '2') {
+            const sku = globalRelations['sku'][transaction.ean];
+            const vector = transaction.vector;
+            vector[AMOUNT_SOLD_MAX] = ((sku === null || sku === void 0 ? void 0 : sku.price) || 0) * vector[QTY_SOLD];
+            vector[AMOUNT_SOLD_DISCOUNT] = vector[AMOUNT_SOLD_MAX] - vector[AMOUNT_SOLD];
+        }
+        if (totals)
+            addTransactionToAggregations(beginTimestamp, endTimestamp, '** TOTAL **', rawAggregations, transaction, maxRows);
+        // Single subtotals are subtotals for first grouper level
+        // Example: for 4 groupers we have rows like
+        // g0 g1 g2 g3 <- normal row with no subtotal
+        // g0          <- subtotal for g0
+        if (subtotalsForOuterGrouper == true) {
+            addTransactionToAggregations(beginTimestamp, endTimestamp, `${aggregateKey.substr(0, aggregateKey.indexOf('\t'))} Σ`, rawAggregations, transaction, maxRows);
+        }
+        if (parentGroupTotals) {
+            const KPIKey = prepareSubTotalAggKey(aggregateKey);
+            addTransactionToAggregations(beginTimestamp, endTimestamp, KPIKey, rawAggregations, transaction, maxRows);
+        }
+        else {
+            addTransactionToAggregations(beginTimestamp, endTimestamp, aggregateKey, rawAggregations, transaction, maxRows);
+        }
+    };
+}
+function aggregate({ beginTimestamp, endTimestamp, filterExpression, aggregationExpression, transactions, beginStock, relations, rawAggregations, maxRows, totals, subtotalsForOuterGrouper, parentGroupTotals, }) {
+    globalNrAggegationExpressions = 0;
+    globalRelations = relations;
+    const compiledAggregator = aggregator({
+        beginTimestamp,
+        endTimestamp,
+        filterExpression,
+        aggregationExpression,
+        rawAggregations,
+        maxRows,
+        totals,
+        subtotalsForOuterGrouper,
+        parentGroupTotals,
+    });
+    if (!beginStock)
+        transactions.filter((t) => t.type != '0').forEach(compiledAggregator);
+    else
+        transactions.forEach(compiledAggregator);
+    return rawAggregations;
+}
+function whichShardsToProcess(dateRange, granularity) {
+    const padl = function (s) {
+        if (s > 9)
+            return '' + s;
+        return '0' + s;
+    };
+    const result = [];
+    if (granularity == 'year')
+        for (let year = dateRange.fromYear; year <= dateRange.toYear; year++)
+            result.push(year);
+    else
+        for (let year = dateRange.fromYear; year <= dateRange.toYear; year++) {
+            if (year == dateRange.fromYear && year < dateRange.toYear)
+                for (let month = dateRange.fromMonth; month <= 12; month++)
+                    result.push('' + year + '' + padl(month));
+            if (year == dateRange.fromYear && year == dateRange.toYear)
+                for (let month = dateRange.fromMonth; month <= dateRange.toMonth; month++)
+                    result.push('' + year + '' + padl(month));
+            if (year != dateRange.fromYear && year != dateRange.toYear)
+                for (let month = 1; month <= 12; month++)
+                    result.push('' + year + '' + padl(month));
+            if (year != dateRange.fromYear && year == dateRange.toYear)
+                for (let month = 1; month <= dateRange.toMonth; month++)
+                    result.push('' + year + '' + padl(month));
+        }
+    return result;
+}
+/**
+ *
+ * @param {*} v: a vector
+ * @param {*} timeFrame: nr miliseconds in timeframe
+ *
+ * Calculate all derived columns on a given vector.
+ */
+function postAgg(v, timeFrame) {
+    v[QTY_END_STOCK] = v[QTY_STOCK] + v[QTY_RECIEVED] - v[QTY_SOLD] + v[QTY_CHANGE] + v[QTY_TRANSIT];
+    v[AMOUNT_END_STOCK] = v[AMOUNT_STOCK] + v[AMOUNT_RECIEVED] - v[COSTPRICE_SOLD] + v[AMOUNT_CHANGE] + v[AMOUNT_TRANSIT] + v[AMOUNT_REVALUATE];
+    v[QTY_END_SHELF_STOCK] = v[QTY_SHELF_STOCK] + v[QTY_RECIEVED] - v[QTY_SOLD] - v[QTY_CONSIGNMENT] + v[QTY_CHANGE] + v[QTY_TRANSIT];
+    v[AMOUNT_END_SHELF_STOCK] = v[AMOUNT_SHELF_STOCK] + v[AMOUNT_RECIEVED] - v[COSTPRICE_SOLD] + v[COSTPRICE_CONSIGNMENT] + v[AMOUNT_CHANGE] + v[AMOUNT_TRANSIT];
+    v[SELLOUT_PERCENTAGE] = (v[QTY_SOLD] / (v[QTY_SOLD] + v[QTY_END_STOCK])) * 100;
+    v[ROI] = v[AMOUNT_SOLD_EXCL] - v[AMOUNT_RECIEVED] + v[AMOUNT_TRANSIT];
+    v[QTY_AVG_STOCK] = (v[QTY_STOCK] * timeFrame + v[STOCK_TIME_PRODUCT]) / timeFrame;
+    v[VALUE_AVG_STOCK] = (v[AMOUNT_STOCK] * timeFrame + v[STOCKAMOUNT_TIME_PRODUCT]) / timeFrame;
+    v[QTY_TURNOVER_VELOCITY] = ((v[QTY_SOLD] / v[QTY_AVG_STOCK]) * msYear) / timeFrame;
+    v[AMOUNT_TURNOVER_VELOCITY] = ((v[COSTPRICE_SOLD] / v[VALUE_AVG_STOCK]) * msYear) / timeFrame;
+    v[PROFIT] = v[AMOUNT_SOLD_EXCL] - v[COSTPRICE_SOLD];
+    v[PROFITABILITY] = (v[PROFIT] / v[COSTPRICE_SOLD]) * v[QTY_TURNOVER_VELOCITY] * 100;
+    v[MARGIN] = (v[PROFIT] / v[AMOUNT_SOLD_EXCL]) * 100;
+    v[RETURN_PERCENTAGE] = (v[QTY_RETURN] / v[QTY_RECIEVED]) * 100;
+    v[QTY_SOLD_BEFORE_RETURNS] = v[QTY_SOLD] + Math.abs(v[QTY_RETURN]);
+}
+function getTimeGrouper(groupers) {
+    if (groupers.includes('transaction.year'))
+        return types_1.TimeGranularityE.YEAR;
+    if (groupers.includes('transaction.month'))
+        return types_1.TimeGranularityE.MONTH;
+    if (groupers.includes('transaction.quarter'))
+        return types_1.TimeGranularityE.QUARTER;
+    if (groupers.includes('transaction.week'))
+        return types_1.TimeGranularityE.WEEK;
+    if (groupers.includes('transaction.day'))
+        return types_1.TimeGranularityE.DAY;
+    return;
+}
+function runQuery(timeframe, rawAggregations, beginStock, transactions, selectedGroupsValues, skus, warehouses, subtotalsForOuterGrouper, computedFilter, parentGroupTotals) {
+    const timeGrouper = getTimeGrouper(selectedGroupsValues);
+    const aggregationExpression = selectedGroupsValues
+        .map((g) => {
+        if (g == 'transaction.year')
+            return '"' + timeframe.hrYear + '"';
+        if (g == 'transaction.quarter')
+            return '"' + timeframe.hrQuarter + '"';
+        if (g == 'transaction.month')
+            return '"' + timeframe.hrMonth + '"';
+        if (g == 'transaction.week')
+            return '"' + timeframe.hrWeek + '"';
+        if (g == 'transaction.day')
+            return '"' + timeframe.hrDay + '"';
+        return g;
+    })
+        .join('+"\t"+');
+    try {
+        aggregate({
+            beginTimestamp: timeframe.beginTimeStamp,
+            endTimestamp: timeframe.endTimeStamp,
+            filterExpression: computedFilter,
+            aggregationExpression: aggregationExpression,
+            transactions: transactions,
+            beginStock: beginStock,
+            relations: {
+                sku: skus,
+                wh: warehouses,
+            },
+            rawAggregations: rawAggregations,
+            maxRows: 100000,
+            totals: timeGrouper === undefined,
+            subtotalsForOuterGrouper,
+            parentGroupTotals,
+        });
+    }
+    catch (e) {
+        return rawAggregations; // most probably an end-user typo in the manualFilter
+    }
+    return rawAggregations;
+}
+const getDateRangeFromPicker = function (inputDates) {
+    if (!Array.isArray(inputDates))
+        return {
+            beginTimeStamp: 0,
+            endTimeStamp: 0,
+            timeFrame: 0,
+            fromYear: 0,
+            toYear: 0,
+            fromMonth: 0,
+            toMonth: 0,
+            hrYear: '',
+            hrQuarter: '',
+            hrMonth: '',
+            hrWeek: '',
+            hrDay: '',
+        };
+    const dates = inputDates.slice();
+    dates.sort((a, b) => {
+        return ('' + a).localeCompare(b);
+    });
+    const fromDate = (0, date_fns_1.parse)(dates[0], 'yyyy-MM-dd', new Date());
+    fromDate.setSeconds(fromDate.getSeconds());
+    const toDate = (0, date_fns_1.parse)(dates[1], 'yyyy-MM-dd', new Date());
+    const beginTimeStamp = fromDate.getTime();
+    const endTimeStamp = toDate.getTime() + 24 * 3600 * 1000;
+    const timeFrame = endTimeStamp - beginTimeStamp;
+    return {
+        beginTimeStamp,
+        endTimeStamp,
+        timeFrame,
+        fromYear: parseInt((0, date_fns_1.format)(fromDate, 'yyyy')),
+        toYear: parseInt((0, date_fns_1.format)(toDate, 'yyyy')),
+        fromMonth: parseInt((0, date_fns_1.format)(fromDate, 'MM')),
+        toMonth: parseInt((0, date_fns_1.format)(toDate, 'MM')),
+        hrYear: (0, date_fns_1.format)(fromDate, 'yyyy'),
+        hrQuarter: (0, date_fns_1.format)(fromDate, 'yyyy-QQQ'),
+        hrMonth: (0, date_fns_1.format)(fromDate, 'yyyy-MM'),
+        hrWeek: (0, date_fns_1.format)(fromDate, 'RRRR-II'),
+        hrDay: (0, date_fns_1.format)(fromDate, 'yyyy-MM-dd'),
+    };
+};
+exports.default = {
+    getDateRangeFromPicker,
+    getTimeGrouper,
+    filtrexOptions,
+    postAgg,
+    runQuery,
+    whichShardsToProcess,
+    AMOUNT_CHANGE,
+    AMOUNT_CONSIGNMENT,
+    AMOUNT_END_SHELF_STOCK,
+    AMOUNT_END_STOCK,
+    AMOUNT_MINIMUM_STOCK,
+    AMOUNT_PO,
+    AMOUNT_PO_COMPLETE,
+    AMOUNT_RECIEVED,
+    AMOUNT_RETURN,
+    AMOUNT_REVALUATE,
+    AMOUNT_SHELF_STOCK,
+    AMOUNT_SOLD,
+    AMOUNT_SOLD_DISCOUNT,
+    AMOUNT_SOLD_EXCL,
+    AMOUNT_SOLD_MAX,
+    AMOUNT_STOCK,
+    AMOUNT_TRANSIT,
+    AMOUNT_TURNOVER_VELOCITY,
+    COSTPRICE_CONSIGNMENT,
+    COSTPRICE_SOLD,
+    MARGIN,
+    MAX_RECIEVE_TIMESTAMP,
+    PROFIT,
+    PROFITABILITY,
+    QTY_AVG_STOCK,
+    QTY_CHANGE,
+    QTY_CONSIGNMENT,
+    QTY_END_SHELF_STOCK,
+    QTY_END_STOCK,
+    QTY_MINIMUM_STOCK,
+    QTY_PO,
+    QTY_PO_COMPLETE,
+    QTY_RECIEVED,
+    QTY_RETURN,
+    QTY_SHELF_STOCK,
+    QTY_SOLD,
+    QTY_SOLD_BEFORE_RETURNS,
+    QTY_STOCK,
+    QTY_TRANSACTION,
+    QTY_TRANSIT,
+    QTY_TURNOVER_VELOCITY,
+    RETURN_PERCENTAGE,
+    ROI,
+    SELLOUT_PERCENTAGE,
+    STOCKAMOUNT_TIME_PRODUCT,
+    STOCK_TIME_PRODUCT,
+    VALUE_AVG_STOCK,
+};

package/dist/index.d.ts

@@ -9,5 +9,6 @@ export { default as sizeToMap } from './sizeToMap';
 export { default as findSkuByBarcode } from './findSkuByBarcode';
 export { default as round2 } from './round2';
 export { default as transaction } from './transaction';
+export { default as articleStatus } from './articleStatus';
 export * from './types';
 export * from './consts';

package/dist/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transaction = exports.round2 = exports.findSkuByBarcode = exports.sizeToMap = exports.hasOnlyDigits = exports.hashBrand = exports.getPreferedPropertyMappings = exports.isean13 = exports.ean13 = exports.deepCopy = exports.buildPropertyMappingFn = void 0;
+exports.articleStatus = exports.transaction = exports.round2 = exports.findSkuByBarcode = exports.sizeToMap = exports.hasOnlyDigits = exports.hashBrand = exports.getPreferedPropertyMappings = exports.isean13 = exports.ean13 = exports.deepCopy = exports.buildPropertyMappingFn = void 0;
 var buildPropertyMappingFn_1 = require("./buildPropertyMappingFn");
 Object.defineProperty(exports, "buildPropertyMappingFn", { enumerable: true, get: function () { return __importDefault(buildPropertyMappingFn_1).default; } });
 var deepCopy_1 = require("./deepCopy");
@@ -40,5 +40,7 @@ var round2_1 = require("./round2");
 Object.defineProperty(exports, "round2", { enumerable: true, get: function () { return __importDefault(round2_1).default; } });
 var transaction_1 = require("./transaction");
 Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return __importDefault(transaction_1).default; } });
+var articleStatus_1 = require("./articleStatus");
+Object.defineProperty(exports, "articleStatus", { enumerable: true, get: function () { return __importDefault(articleStatus_1).default; } });
 __exportStar(require("./types"), exports);
 __exportStar(require("./consts"), exports);

package/dist/types.d.ts

@@ -256,6 +256,8 @@ interface dbTransactionI {
     docnr: string;
     time: number;
     vector: number[];
+    row?: number;
+    unixtime?: number;
 }
 interface TransactionI {
     type: transactionTypeE;
@@ -269,5 +271,54 @@ interface TransactionI {
     sellprice: number;
     vat?: number;
     buyprice: number;
+    vector: Float64Array;
 }
-export { RowI, StockTransferSelectionI, MarkedSkuI, vatCategoryE, tagTypeE, SkuI, GroupI, ProductI, ImageI, AttributeI, ColorI, MatrixI, StockTransferDataI, StockTransferMatrixI, BrandSettingI, mappingStrategyE, subscriptionE, dbTransactionI, TransactionI, transactionTypeE, };
+type RaGI = Record<string, Float64Array>;
+interface AggregateFnI {
+    beginTimestamp: number;
+    endTimestamp: number;
+    filterExpression: string;
+    aggregationExpression: string;
+    transactions: TransactionI[];
+    beginStock: boolean;
+    relations: any;
+    rawAggregations: RaGI;
+    maxRows: number;
+    totals: boolean;
+    subtotalsForOuterGrouper?: boolean;
+    parentGroupTotals?: boolean;
+}
+interface AggregatorFnI {
+    beginTimestamp: number;
+    endTimestamp: number;
+    filterExpression: string;
+    aggregationExpression: string;
+    rawAggregations: RaGI;
+    maxRows: number;
+    totals: boolean;
+    subtotalsForOuterGrouper?: boolean;
+    reportViz?: string;
+    parentGroupTotals?: boolean;
+}
+interface HrTimeframeI {
+    beginTimeStamp: number;
+    endTimeStamp: number;
+    timeFrame: number;
+    fromYear: number;
+    toYear: number;
+    fromMonth: number;
+    toMonth: number;
+    hrYear: string;
+    hrQuarter: string;
+    hrMonth: string;
+    hrWeek: string;
+    hrDay: string;
+}
+declare enum TimeGranularityE {
+    DAY = "day",
+    WEEK = "week",
+    MONTH = "month",
+    QUARTER = "quarter",
+    YEAR = "year"
+}
+export { RowI, StockTransferSelectionI, MarkedSkuI, vatCategoryE, tagTypeE, SkuI, GroupI, ProductI, ImageI, AttributeI, ColorI, MatrixI, StockTransferDataI, StockTransferMatrixI, BrandSettingI, mappingStrategyE, subscriptionE, dbTransactionI, TransactionI, transactionTypeE, HrTimeframeI, TimeGranularityE, AggregatorFnI, AggregateFnI, RaGI, };

package/dist/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transactionTypeE = exports.subscriptionE = exports.mappingStrategyE = exports.tagTypeE = exports.vatCategoryE = void 0;
+exports.TimeGranularityE = exports.transactionTypeE = exports.subscriptionE = exports.mappingStrategyE = exports.tagTypeE = exports.vatCategoryE = void 0;
 var subscriptionE;
 (function (subscriptionE) {
     subscriptionE["DATA_ONLY"] = "data_only";
@@ -54,3 +54,12 @@ var transactionTypeE;
     transactionTypeE["OFFER"] = "98";
 })(transactionTypeE || (transactionTypeE = {}));
 exports.transactionTypeE = transactionTypeE;
+var TimeGranularityE;
+(function (TimeGranularityE) {
+    TimeGranularityE["DAY"] = "day";
+    TimeGranularityE["WEEK"] = "week";
+    TimeGranularityE["MONTH"] = "month";
+    TimeGranularityE["QUARTER"] = "quarter";
+    TimeGranularityE["YEAR"] = "year";
+})(TimeGranularityE || (TimeGranularityE = {}));
+exports.TimeGranularityE = TimeGranularityE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softwear/latestcollectioncore",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "Core functions for LatestCollections applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,5 +26,9 @@
     "mocha": "^10.2.0",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "date-fns": "^3.0.0",
+    "filtrex": "^3.0.0"
   }
 }

package/src/articleStatus.ts

@@ -0,0 +1,464 @@
+import { compileExpression } from 'filtrex'
+import { TransactionI, RaGI, AggregateFnI, AggregatorFnI, HrTimeframeI, TimeGranularityE, SkuI } from './types'
+import transaction from './transaction'
+import { format, parse } from 'date-fns'
+
+// fields in Vector
+const {
+  QTY_TRANSACTION,
+  QTY_STOCK,
+  AMOUNT_STOCK,
+  QTY_SHELF_STOCK,
+  AMOUNT_SHELF_STOCK,
+  AMOUNT_REVALUATE,
+  QTY_RECIEVED,
+  AMOUNT_RECIEVED,
+  QTY_SOLD,
+  AMOUNT_SOLD,
+  AMOUNT_SOLD_EXCL,
+  COSTPRICE_SOLD,
+  QTY_CHANGE,
+  AMOUNT_CHANGE,
+  QTY_TRANSIT,
+  AMOUNT_TRANSIT,
+  QTY_PO,
+  AMOUNT_PO,
+  QTY_PO_COMPLETE,
+  AMOUNT_PO_COMPLETE,
+  QTY_MINIMUM_STOCK,
+  AMOUNT_MINIMUM_STOCK,
+  QTY_CONSIGNMENT,
+  AMOUNT_CONSIGNMENT,
+  COSTPRICE_CONSIGNMENT,
+} = transaction.transactionVector
+
+// DERIVED FIELDS
+const AMOUNT_SOLD_MAX = 25
+const AMOUNT_SOLD_DISCOUNT = 26
+const MAX_RECIEVE_TIMESTAMP = 27
+const STOCK_TIME_PRODUCT = 28
+const STOCKAMOUNT_TIME_PRODUCT = 29
+const QTY_RETURN = 30
+const AMOUNT_RETURN = 31
+
+// Vector length to allocate for aggregation
+const VECTOR_LENGTH = 32
+
+// POST AGGREGATION COLUMNS
+const SELLOUT_PERCENTAGE = 32
+const ROI = 33
+const QTY_AVG_STOCK = 34
+const VALUE_AVG_STOCK = 35
+const QTY_TURNOVER_VELOCITY = 36
+const AMOUNT_TURNOVER_VELOCITY = 37
+const PROFITABILITY = 38
+const MARGIN = 39
+const PROFIT = 40
+const QTY_END_SHELF_STOCK = 41
+const AMOUNT_END_SHELF_STOCK = 42
+const QTY_END_STOCK = 43
+const AMOUNT_END_STOCK = 44
+const RETURN_PERCENTAGE = 45
+const QTY_SOLD_BEFORE_RETURNS = 46
+
+const BEGIN_STOCK_VECTOR_START = QTY_STOCK
+const BEGIN_STOCK_VECTOR_END = AMOUNT_SHELF_STOCK + 1
+
+const msYear = 24 * 3600 * 365 * 1000
+const globalJoinableTables = { sku: 'ean', wh: 'wh', transaction: 'row' } // defines the keys we can join on
+
+/**
+ * Global variables
+ */
+let globalRelations = {} // holds the joined tables
+let globalNrAggegationExpressions = 0 // tracks the # aggregations rows so we can quit computing if it grows out of bounds
+
+/**
+ * The propFunction for FiltreX needs some data that can't be passed as parameters. That's why the 'globalsRelations' variable is needed.
+ * TODO: Functional: Experiment with curried functions
+ */
+function propFunction(propertyName: string, getPropertyName: Function, obj: Record<string, any>): any {
+  const positionOfDot = propertyName.indexOf('.')
+  if (positionOfDot < 0) return getPropertyName(propertyName)
+  const table = propertyName.substring(0, positionOfDot)
+  const field = propertyName.substring(positionOfDot + 1)
+  if (table == 'transaction') return getPropertyName(field)
+  return globalRelations[table]?.[obj[globalJoinableTables[table]]]?.[field] || '~ ?'
+}
+
+const lower = (s: string) => s.toLowerCase()
+const upper = (s: string) => s.toUpperCase()
+
+const filtrexOptions = {
+  extraFunctions: { lower, upper },
+  customProp: propFunction,
+}
+
+// This is how the actual joining of 2 vectors happens
+function addVectors(targetVector: Float64Array, otherVector: Float64Array, begin: number, end: number): void {
+  for (let i = begin; i < end; i++) targetVector[i] += otherVector[i] || 0
+}
+
+// This function takes a transaction and adds it to the aggregations
+function addTransactionToAggregations(beginTimestamp: number, endTimestamp: number, aggregateKey: string, rawAggregations: RaGI, transaction: TransactionI, maxRows: number): void {
+  let aggregateVector = rawAggregations[aggregateKey]
+  if (globalNrAggegationExpressions >= maxRows) return
+  if (!aggregateVector) {
+    globalNrAggegationExpressions++
+    aggregateVector = new Float64Array(VECTOR_LENGTH)
+    rawAggregations[aggregateKey] = aggregateVector
+  }
+  const vector = transaction.vector
+  if (transaction.type == '1' && transaction.time > aggregateVector[MAX_RECIEVE_TIMESTAMP]) aggregateVector[MAX_RECIEVE_TIMESTAMP] = transaction.time
+  if (transaction.time <= beginTimestamp) return addVectors(aggregateVector, vector, BEGIN_STOCK_VECTOR_START, BEGIN_STOCK_VECTOR_END)
+  if (transaction.time > endTimestamp) return
+  addVectors(aggregateVector, vector, BEGIN_STOCK_VECTOR_END, vector.length)
+
+  // Calculate derived fields
+
+  aggregateVector[QTY_RETURN] += vector[QTY_SOLD] < 0 ? vector[QTY_SOLD] : 0
+  aggregateVector[AMOUNT_RETURN] += vector[AMOUNT_SOLD_EXCL] < 0 ? vector[AMOUNT_SOLD_EXCL] : 0
+
+  aggregateVector[STOCK_TIME_PRODUCT] +=
+    (vector[QTY_RECIEVED] || 0 + vector[QTY_TRANSIT] || 0 + vector[QTY_CHANGE] || 0 - vector[QTY_SOLD] || 0) * (endTimestamp - transaction.time)
+  aggregateVector[STOCKAMOUNT_TIME_PRODUCT] +=
+    (vector[AMOUNT_RECIEVED] || 0 + vector[AMOUNT_TRANSIT] || 0 + vector[AMOUNT_CHANGE] || 0 - vector[COSTPRICE_SOLD] || 0) * (endTimestamp - transaction.time)
+}
+
+function buildAggregationEvaluator(aggregationExpression: string): Function {
+  return compileExpression(aggregationExpression, filtrexOptions)
+}
+
+function prepareSubTotalAggKey(aggKey) {
+  return aggKey.split('\t').slice(0, -1).join('\t').concat(' Σ')
+}
+
+/*
+ * A factory function that returns a function that can be used to aggregate transactions
+ * The factory function is called once for each aggregationExpression
+ * @param {Object} options
+ *
+ * @param {number} options.beginTimestamp - The begin of the time frame UNIX timestamp
+ * @param {number} options.endTimestamp - The end of the time frame UNIX timestamp
+ *
+ * @param {string} options.filterExpression - The FiltreX preprocessed filter expression for: brand, collection, warehouse and articleGroup
+ * Example: sku.brand in ("Gabor") and sku.collection not in ("21summer")
+ *
+ * @param {string} options.aggregationExpression - The aggregation expression that contains the aggregateKey
+ * Example: sku.brand+"	"+sku.collection+"	"+sku.articleGroup+"	"+sku.articleCodeSupplier
+ *
+ * @param {Object} options.rawAggregations - The raw aggregations object where keys are the aggregateKeys and values are the Float64Array vectors
+ *
+ * @param {number} options.maxRows - The maximum number of rows to aggregate
+ * @param {boolean} options.totals - Whether to aggregate totals
+ * @param {boolean} options.subtotalsForOuterGrouper - Whether to aggregate single subtotals
+ *
+ * @returns {Function} - The aggregator function
+ */
+function aggregator({
+  beginTimestamp,
+  endTimestamp,
+  filterExpression,
+  aggregationExpression,
+  rawAggregations,
+  maxRows,
+  totals,
+  subtotalsForOuterGrouper,
+  parentGroupTotals,
+}: AggregatorFnI) {
+  const filterExpressionCache = {}
+
+  let filter
+  let filterDependencyEvaluator
+  if (filterExpression) {
+    filter = compileExpression(filterExpression, filtrexOptions)
+    // Maintain a cache of evaluated filterExpressions
+    // The granularity of the cache is determined by the joined tables in the filterExpression
+    const filterGranularity = Object.entries(globalJoinableTables)
+      .filter((join) => filterExpression.includes(join[0] + '.'))
+      .map((join) => join[1])
+    filterDependencyEvaluator = compileExpression(filterGranularity.join('+'))
+  }
+  const aggregationEvaluator = buildAggregationEvaluator(aggregationExpression)
+  // Maintain a cache of evaluated aggregationExpressions
+  // The granularity of the cache is determined by the joined tables in the aggregationExpression
+  const aggregationExpressionCache = {}
+  const aggregationGranularity = Object.entries(globalJoinableTables)
+    .filter((join) => aggregationExpression.includes(join[0] + '.'))
+    .map((join) => join[1])
+
+  let aggregationDependencyExpression = aggregationGranularity.join('+')
+  if (!aggregationDependencyExpression) aggregationDependencyExpression = '"N.A."'
+  const aggregationDependencyEvaluator = compileExpression(aggregationDependencyExpression)
+  return function (transaction: TransactionI): void {
+    if (filter) {
+      const filterDependency = filterDependencyEvaluator(transaction)
+      const filterExpression = filterExpressionCache[filterDependency]
+      if (filterExpression == -1) return
+      if (!filterExpression) {
+        filterExpressionCache[filterDependency] = filter(transaction) ? 1 : -1
+        if (filterExpressionCache[filterDependency] == -1) return
+      }
+    }
+    const aggregationDependency = aggregationDependencyEvaluator(transaction)
+    let aggregateKey = aggregationExpressionCache[aggregationDependency]
+    if (!aggregateKey) {
+      aggregateKey = aggregationEvaluator(transaction)
+      aggregationExpressionCache[aggregationDependency] = aggregateKey
+    }
+    // Prepare joined values for derived fields
+    if (transaction.type == '2') {
+      const sku = globalRelations['sku'][transaction.ean]
+      const vector = transaction.vector
+      vector[AMOUNT_SOLD_MAX] = (sku?.price || 0) * vector[QTY_SOLD]
+      vector[AMOUNT_SOLD_DISCOUNT] = vector[AMOUNT_SOLD_MAX] - vector[AMOUNT_SOLD]
+    }
+
+    if (totals) addTransactionToAggregations(beginTimestamp, endTimestamp, '** TOTAL **', rawAggregations, transaction, maxRows)
+
+    // Single subtotals are subtotals for first grouper level
+    // Example: for 4 groupers we have rows like
+    // g0 g1 g2 g3 <- normal row with no subtotal
+    // g0          <- subtotal for g0
+    if (subtotalsForOuterGrouper == true) {
+      addTransactionToAggregations(beginTimestamp, endTimestamp, `${aggregateKey.substr(0, aggregateKey.indexOf('\t'))} Σ`, rawAggregations, transaction, maxRows)
+    }
+
+    if (parentGroupTotals) {
+      const KPIKey = prepareSubTotalAggKey(aggregateKey)
+      addTransactionToAggregations(beginTimestamp, endTimestamp, KPIKey, rawAggregations, transaction, maxRows)
+    } else {
+      addTransactionToAggregations(beginTimestamp, endTimestamp, aggregateKey, rawAggregations, transaction, maxRows)
+    }
+  }
+}
+
+function aggregate({
+  beginTimestamp,
+  endTimestamp,
+  filterExpression,
+  aggregationExpression,
+  transactions,
+  beginStock,
+  relations,
+  rawAggregations,
+  maxRows,
+  totals,
+  subtotalsForOuterGrouper,
+  parentGroupTotals,
+}: AggregateFnI) {
+  globalNrAggegationExpressions = 0
+  globalRelations = relations
+
+  const compiledAggregator = aggregator({
+    beginTimestamp,
+    endTimestamp,
+    filterExpression,
+    aggregationExpression,
+    rawAggregations,
+    maxRows,
+    totals,
+    subtotalsForOuterGrouper,
+    parentGroupTotals,
+  })
+  if (!beginStock) transactions.filter((t: TransactionI) => t.type != '0').forEach(compiledAggregator)
+  else transactions.forEach(compiledAggregator)
+
+  return rawAggregations
+}
+function whichShardsToProcess(dateRange: any, granularity: 'year' | 'month'): any[] {
+  const padl = function (s: number) {
+    if (s > 9) return '' + s
+    return '0' + s
+  }
+  const result = [] as any[]
+  if (granularity == 'year') for (let year = dateRange.fromYear; year <= dateRange.toYear; year++) result.push(year)
+  else
+    for (let year = dateRange.fromYear; year <= dateRange.toYear; year++) {
+      if (year == dateRange.fromYear && year < dateRange.toYear) for (let month = dateRange.fromMonth; month <= 12; month++) result.push('' + year + '' + padl(month))
+      if (year == dateRange.fromYear && year == dateRange.toYear)
+        for (let month = dateRange.fromMonth; month <= dateRange.toMonth; month++) result.push('' + year + '' + padl(month))
+      if (year != dateRange.fromYear && year != dateRange.toYear) for (let month = 1; month <= 12; month++) result.push('' + year + '' + padl(month))
+      if (year != dateRange.fromYear && year == dateRange.toYear) for (let month = 1; month <= dateRange.toMonth; month++) result.push('' + year + '' + padl(month))
+    }
+  return result
+}
+/**
+ *
+ * @param {*} v: a vector
+ * @param {*} timeFrame: nr miliseconds in timeframe
+ *
+ * Calculate all derived columns on a given vector.
+ */
+function postAgg(v: any, timeFrame: number): void {
+  v[QTY_END_STOCK] = v[QTY_STOCK] + v[QTY_RECIEVED] - v[QTY_SOLD] + v[QTY_CHANGE] + v[QTY_TRANSIT]
+  v[AMOUNT_END_STOCK] = v[AMOUNT_STOCK] + v[AMOUNT_RECIEVED] - v[COSTPRICE_SOLD] + v[AMOUNT_CHANGE] + v[AMOUNT_TRANSIT] + v[AMOUNT_REVALUATE]
+  v[QTY_END_SHELF_STOCK] = v[QTY_SHELF_STOCK] + v[QTY_RECIEVED] - v[QTY_SOLD] - v[QTY_CONSIGNMENT] + v[QTY_CHANGE] + v[QTY_TRANSIT]
+  v[AMOUNT_END_SHELF_STOCK] = v[AMOUNT_SHELF_STOCK] + v[AMOUNT_RECIEVED] - v[COSTPRICE_SOLD] + v[COSTPRICE_CONSIGNMENT] + v[AMOUNT_CHANGE] + v[AMOUNT_TRANSIT]
+  v[SELLOUT_PERCENTAGE] = (v[QTY_SOLD] / (v[QTY_SOLD] + v[QTY_END_STOCK])) * 100
+  v[ROI] = v[AMOUNT_SOLD_EXCL] - v[AMOUNT_RECIEVED] + v[AMOUNT_TRANSIT]
+  v[QTY_AVG_STOCK] = (v[QTY_STOCK] * timeFrame + v[STOCK_TIME_PRODUCT]) / timeFrame
+  v[VALUE_AVG_STOCK] = (v[AMOUNT_STOCK] * timeFrame + v[STOCKAMOUNT_TIME_PRODUCT]) / timeFrame
+  v[QTY_TURNOVER_VELOCITY] = ((v[QTY_SOLD] / v[QTY_AVG_STOCK]) * msYear) / timeFrame
+  v[AMOUNT_TURNOVER_VELOCITY] = ((v[COSTPRICE_SOLD] / v[VALUE_AVG_STOCK]) * msYear) / timeFrame
+  v[PROFIT] = v[AMOUNT_SOLD_EXCL] - v[COSTPRICE_SOLD]
+  v[PROFITABILITY] = (v[PROFIT] / v[COSTPRICE_SOLD]) * v[QTY_TURNOVER_VELOCITY] * 100
+  v[MARGIN] = (v[PROFIT] / v[AMOUNT_SOLD_EXCL]) * 100
+  v[RETURN_PERCENTAGE] = (v[QTY_RETURN] / v[QTY_RECIEVED]) * 100
+  v[QTY_SOLD_BEFORE_RETURNS] = v[QTY_SOLD] + Math.abs(v[QTY_RETURN])
+}
+
+function getTimeGrouper(groupers: string[]): TimeGranularityE | undefined {
+  if (groupers.includes('transaction.year')) return TimeGranularityE.YEAR
+  if (groupers.includes('transaction.month')) return TimeGranularityE.MONTH
+  if (groupers.includes('transaction.quarter')) return TimeGranularityE.QUARTER
+  if (groupers.includes('transaction.week')) return TimeGranularityE.WEEK
+  if (groupers.includes('transaction.day')) return TimeGranularityE.DAY
+  return
+}
+
+function runQuery(
+  timeframe: HrTimeframeI,
+  rawAggregations: RaGI,
+  beginStock: boolean,
+  transactions: TransactionI[],
+  selectedGroupsValues: string[],
+  skus: SkuI[],
+  warehouses: any[],
+  subtotalsForOuterGrouper: boolean,
+  computedFilter: string,
+  parentGroupTotals: boolean
+) {
+  const timeGrouper = getTimeGrouper(selectedGroupsValues)
+  const aggregationExpression = selectedGroupsValues
+    .map((g) => {
+      if (g == 'transaction.year') return '"' + timeframe.hrYear + '"'
+      if (g == 'transaction.quarter') return '"' + timeframe.hrQuarter + '"'
+      if (g == 'transaction.month') return '"' + timeframe.hrMonth + '"'
+      if (g == 'transaction.week') return '"' + timeframe.hrWeek + '"'
+      if (g == 'transaction.day') return '"' + timeframe.hrDay + '"'
+      return g
+    })
+    .join('+"\t"+')
+  try {
+    aggregate({
+      beginTimestamp: timeframe.beginTimeStamp,
+      endTimestamp: timeframe.endTimeStamp,
+      filterExpression: computedFilter,
+      aggregationExpression: aggregationExpression,
+      transactions: transactions,
+      beginStock: beginStock,
+      relations: {
+        sku: skus,
+        wh: warehouses,
+      },
+      rawAggregations: rawAggregations,
+      maxRows: 100000,
+      totals: timeGrouper === undefined,
+      subtotalsForOuterGrouper,
+      parentGroupTotals,
+    })
+  } catch (e) {
+    return rawAggregations // most probably an end-user typo in the manualFilter
+  }
+  return rawAggregations
+}
+
+const getDateRangeFromPicker = function (inputDates: string[]): HrTimeframeI {
+  if (!Array.isArray(inputDates))
+    return {
+      beginTimeStamp: 0,
+      endTimeStamp: 0,
+      timeFrame: 0,
+      fromYear: 0,
+      toYear: 0,
+      fromMonth: 0,
+      toMonth: 0,
+      hrYear: '',
+      hrQuarter: '',
+      hrMonth: '',
+      hrWeek: '',
+      hrDay: '',
+    }
+  const dates = inputDates.slice()
+  dates.sort((a, b) => {
+    return ('' + a).localeCompare(b)
+  })
+  const fromDate = parse(dates[0], 'yyyy-MM-dd', new Date())
+  fromDate.setSeconds(fromDate.getSeconds())
+
+  const toDate = parse(dates[1], 'yyyy-MM-dd', new Date())
+  const beginTimeStamp = fromDate.getTime()
+  const endTimeStamp = toDate.getTime() + 24 * 3600 * 1000
+  const timeFrame = endTimeStamp - beginTimeStamp
+  return {
+    beginTimeStamp,
+    endTimeStamp,
+    timeFrame,
+    fromYear: parseInt(format(fromDate, 'yyyy')),
+    toYear: parseInt(format(toDate, 'yyyy')),
+    fromMonth: parseInt(format(fromDate, 'MM')),
+    toMonth: parseInt(format(toDate, 'MM')),
+    hrYear: format(fromDate, 'yyyy'),
+    hrQuarter: format(fromDate, 'yyyy-QQQ'),
+    hrMonth: format(fromDate, 'yyyy-MM'),
+    hrWeek: format(fromDate, 'RRRR-II'),
+    hrDay: format(fromDate, 'yyyy-MM-dd'),
+  }
+}
+
+export default {
+  getDateRangeFromPicker,
+  getTimeGrouper,
+  filtrexOptions,
+  postAgg,
+  runQuery,
+  whichShardsToProcess,
+  AMOUNT_CHANGE,
+  AMOUNT_CONSIGNMENT,
+  AMOUNT_END_SHELF_STOCK,
+  AMOUNT_END_STOCK,
+  AMOUNT_MINIMUM_STOCK,
+  AMOUNT_PO,
+  AMOUNT_PO_COMPLETE,
+  AMOUNT_RECIEVED,
+  AMOUNT_RETURN,
+  AMOUNT_REVALUATE,
+  AMOUNT_SHELF_STOCK,
+  AMOUNT_SOLD,
+  AMOUNT_SOLD_DISCOUNT,
+  AMOUNT_SOLD_EXCL,
+  AMOUNT_SOLD_MAX,
+  AMOUNT_STOCK,
+  AMOUNT_TRANSIT,
+  AMOUNT_TURNOVER_VELOCITY,
+  COSTPRICE_CONSIGNMENT,
+  COSTPRICE_SOLD,
+  MARGIN,
+  MAX_RECIEVE_TIMESTAMP,
+  PROFIT,
+  PROFITABILITY,
+  QTY_AVG_STOCK,
+  QTY_CHANGE,
+  QTY_CONSIGNMENT,
+  QTY_END_SHELF_STOCK,
+  QTY_END_STOCK,
+  QTY_MINIMUM_STOCK,
+  QTY_PO,
+  QTY_PO_COMPLETE,
+  QTY_RECIEVED,
+  QTY_RETURN,
+  QTY_SHELF_STOCK,
+  QTY_SOLD,
+  QTY_SOLD_BEFORE_RETURNS,
+  QTY_STOCK,
+  QTY_TRANSACTION,
+  QTY_TRANSIT,
+  QTY_TURNOVER_VELOCITY,
+  RETURN_PERCENTAGE,
+  ROI,
+  SELLOUT_PERCENTAGE,
+  STOCKAMOUNT_TIME_PRODUCT,
+  STOCK_TIME_PRODUCT,
+  VALUE_AVG_STOCK,
+}

package/src/index.ts

@@ -9,5 +9,6 @@ export { default as sizeToMap } from './sizeToMap'
 export { default as findSkuByBarcode } from './findSkuByBarcode'
 export { default as round2 } from './round2'
 export { default as transaction } from './transaction'
+export { default as articleStatus } from './articleStatus'
 export * from './types'
 export * from './consts'

package/src/types.ts

@@ -272,6 +272,8 @@ interface dbTransactionI {
   docnr: string
   time: number
   vector: number[]
+  row?: number
+  unixtime?: number
 }
 interface TransactionI {
   type: transactionTypeE
@@ -285,7 +287,61 @@ interface TransactionI {
   sellprice: number
   vat?: number
   buyprice: number
+  vector: Float64Array
 }
+
+type RaGI = Record<string, Float64Array>
+
+interface AggregateFnI {
+  beginTimestamp: number
+  endTimestamp: number
+  filterExpression: string
+  aggregationExpression: string
+  transactions: TransactionI[]
+  beginStock: boolean
+  relations: any
+  rawAggregations: RaGI
+  maxRows: number
+  totals: boolean
+  subtotalsForOuterGrouper?: boolean
+  parentGroupTotals?: boolean
+}
+
+interface AggregatorFnI {
+  beginTimestamp: number
+  endTimestamp: number
+  filterExpression: string
+  aggregationExpression: string
+  rawAggregations: RaGI
+  maxRows: number
+  totals: boolean
+  subtotalsForOuterGrouper?: boolean
+  reportViz?: string
+  parentGroupTotals?: boolean
+}
+interface HrTimeframeI {
+  beginTimeStamp: number
+  endTimeStamp: number
+  timeFrame: number
+  fromYear: number
+  toYear: number
+  fromMonth: number
+  toMonth: number
+  hrYear: string
+  hrQuarter: string
+  hrMonth: string
+  hrWeek: string
+  hrDay: string
+}
+
+enum TimeGranularityE {
+  DAY = 'day',
+  WEEK = 'week',
+  MONTH = 'month',
+  QUARTER = 'quarter',
+  YEAR = 'year',
+}
+
 export {
   RowI,
   StockTransferSelectionI,
@@ -307,4 +363,9 @@ export {
   dbTransactionI,
   TransactionI,
   transactionTypeE,
+  HrTimeframeI,
+  TimeGranularityE,
+  AggregatorFnI,
+  AggregateFnI,
+  RaGI,
 }