@provoly/dashboard 0.15.9 → 0.15.11

package/fesm2022/provoly-dashboard.mjs

@@ -2573,7 +2573,7 @@ class PryModalStatusComponent {
                 .flat()
                 .map((preview) => ({
                 ...preview,
-                name: preview.name.split(',').join(', ')
+                name: (preview.name ?? '').split(',').join(', ')
             }))));
             this.messageCount$ = this.store.select(DataSourceSelectors.datasetPreviews).pipe(map((previews) => {
                 return previews.map((preview) => preview.count).reduce((p, c) => p + c, 0);
@@ -3856,7 +3856,7 @@ const namedQueriesUses = createSelector(globalManifest, (manifest) => manifest.w
 const presentation = createSelector(feature$4, (state) => state?.presentation);
 const isCurrentPresentationModified = createSelector(presentation, globalManifest, (state, global) => !equal(global, state.initial));
 const isCurrentPresentationOwner = createSelector(presentation, (state) => !!state.current && state.current.owner);
-const filters = createSelector(feature$4, (state) => state?.manifests.manifest.filters ?? {});
+const filters = createSelector(feature$4, (state) => state?.manifests.manifest.filters ?? []);
 const datasourceFilters = createSelector(feature$4, (state) => state?.manifests.manifest.filters
     ? state?.manifests.manifest.filters.reduce((obj, filter) => (filter.attributes.forEach((attribute) => (obj[attribute.datasource] || (obj[attribute.datasource] = [])).push({
         attribute: attribute.id,
@@ -5285,195 +5285,261 @@ class ResultsetUtils {
     }
 }
 
-class PryFrontendAggregationService extends PryAggregationService {
-    constructor(store) {
-        super();
-        this.store = store;
+class AggregationUtils {
+    static getAxisAttribute(classes, options, axis) {
+        return classes
+            .map((clazz) => clazz.attributes.find((attr) => attr.id === options[axis].attribute))
+            .find((attr) => !!attr)?.name;
     }
-    // @ts-ignore
-    aggregate(datasource, options) {
-        return combineLatest([
-            this.store.select(DashboardSelectors.resultSets),
-            this.store.select(ClassSelectors.classes)
-        ]).pipe(map(([resultSets, classes]) => {
-            const abscissa = classes
-                .map((clazz) => clazz.attributes.find((attr) => attr.id === options.abscissa.attribute))
-                .find((attr) => !!attr)?.name;
-            const ordinate = classes
-                .map((clazz) => clazz.attributes.find((attr) => attr.id === options.ordinate.attribute))
-                .find((attr) => !!attr)?.name;
-            if (!abscissa || !ordinate) {
-                throw new Error('abscissaorodinateinvalid');
-            }
-            let data = datasource.map((rsName) => resultSets[rsName ?? '']).filter((rsName) => !!rsName);
-            const resultSet = data.reduce((rs1, rs2) => ResultsetUtils.mergeResultSets(rs1, rs2), {
-                items: {},
-                relations: [],
-                merged: data.length
-            });
-            let items = Object.keys(resultSet.items)
-                .map((classId) => resultSet.items[classId])
-                .reduce((prev, curr) => [...prev, ...curr], []);
-            if (!!options.groupBy) {
-                const groupBy = classes
-                    .map((clazz) => clazz.attributes.find((attr) => attr.id === options.groupBy?.attribute))
-                    .find((attr) => !!attr)?.name;
-                if (!groupBy) {
-                    throw new Error('groupByAttributeisinvalid');
-                }
-                const itemsGrouped = this.groupBy(items, groupBy);
-                const values = [];
-                Object.keys(itemsGrouped).forEach((key) => {
-                    values.push({
-                        key,
-                        groupBy: this.getValueFromOperation(itemsGrouped[key], options.ordinate.operation, abscissa, ordinate, options.abscissa.limit)
-                    });
-                });
-                return { operation: options.ordinate.operation, values: values };
-            }
-            const values = this.getValueFromOperation(items, options.ordinate.operation, abscissa, ordinate, options.abscissa.limit);
-            return { operation: options.ordinate.operation, values: values };
-        }));
+    static getChartDatasourceResultSet(datasources, resultSets) {
+        return datasources
+            .filter((rsName) => rsName in resultSets)
+            .map((rsName) => resultSets[rsName])
+            .reduce((rs1, rs2) => ResultsetUtils.mergeResultSets(rs1, rs2), {
+            items: {},
+            relations: [],
+            merged: datasources.filter((rsName) => rsName in resultSets).length
+        });
+    }
+    static getAggregatedValue(operation, groupedItems, abscissaAttribute, ordinateAttribute) {
+        return this.getAggregatedValueForOperation(operation, groupedItems[abscissaAttribute].map((item) => this.getValueFromAttribute(item, ordinateAttribute).value));
     }
-    getValueFromOperation(items, operation, abscissa, ordinate, limit) {
-        let result = [];
-        const groupByAbscissa = this.groupBy(items, abscissa);
-        groupByAbscissa.map((test) => console.log(groupByAbscissa[test]));
+    static getValueFromAttribute(item, attribute) {
+        let value = ItemUtils.getAttributeValue(item, attribute);
+        return Array.isArray(value) ? value[0] : value;
+    }
+    static getAggregatedValueForOperation(operation, values) {
         switch (operation) {
             case Operation.COUNT:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: groupByAbscissa[key].length
-                })));
-                break;
+                return values.length;
             case Operation.SUM:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getSum(groupByAbscissa[key], ordinate)
-                })));
-                break;
+                return values.reduce((acc, val) => acc + val, 0);
             case Operation.DISTINCT:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getDistinct(groupByAbscissa[key], ordinate)
-                })));
-                break;
+                return [...new Set(values)].length;
             case Operation.AVERAGE:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getAverage(groupByAbscissa[key], ordinate)
-                })));
-                break;
+                return values.reduce((acc, val) => acc + val, 0) / values.length;
             case Operation.MEDIAN:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getQuartile(groupByAbscissa[key], ordinate, 0.5)
-                })));
-                break;
+                return this.getQuartile(values, 0.5);
             case Operation.Q1:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getQuartile(groupByAbscissa[key], ordinate, 0.25)
-                })));
-                break;
+                return this.getQuartile(values, 0.25);
             case Operation.Q3:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getQuartile(groupByAbscissa[key], ordinate, 0.75)
-                })));
-                break;
+                return this.getQuartile(values, 0.75);
             case Operation.MIN:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getMin(groupByAbscissa[key], ordinate)
-                })));
-                break;
+                return Math.min(...values);
+            case Operation.MAX:
+                return Math.max(...values);
             default:
-                result.push(...Object.keys(groupByAbscissa).map((key) => ({
-                    key: key,
-                    value: this.getMax(groupByAbscissa[key], ordinate)
-                })));
-                break;
+                return -1;
         }
-        if (limit) {
-            result = this.formatByLimit(result, limit);
+    }
+    static getQuartile(values, q) {
+        if (values.length === 0)
+            return 0;
+        values.sort((a, b) => a - b);
+        let pos = (values.length - 1) * q;
+        if (pos % 1 === 0) {
+            return values[pos];
         }
-        return result;
+        pos = Math.floor(pos);
+        return values[pos + 1] !== undefined ? (values[pos] + values[pos + 1]) / 2 : values[pos];
     }
-    groupBy(items, attribute) {
-        let distincts = [];
-        items.forEach((item) => {
-            let value = this.getValueFromAttribute(item, attribute);
-            if (distincts[value.value]) {
-                distincts[value.value].push(item);
+    static formatByLimit(data, limit, operation) {
+        if (!limit.isTimeLimit) {
+            data
+                .sort((a, b) => (limit.order === 'asc' ? (a.value > b.value ? 1 : -1) : a.value < b.value ? 1 : -1))
+                .splice(limit.at);
+            return data;
+        }
+        return this.formatDataByTimeLimit(data, limit, operation);
+    }
+    static formatDataByTimeLimit(data, limit, operation) {
+        let distinctValues = [];
+        data
+            .map((obj) => ({ ...obj, key: this.getKeyValueForTimeInterval(obj.key, limit.interval) }))
+            .forEach((obj) => {
+            const isNotDistinct = distinctValues.find((distinct) => obj.key === distinct.key);
+            if (!!isNotDistinct) {
+                isNotDistinct.values.push(obj.value);
             }
             else {
-                distincts[value.value] = [item];
+                distinctValues.push({ key: obj.key, values: [] });
             }
         });
-        return distincts;
-    }
-    getValueFromAttribute(item, attribute) {
-        let value = ItemUtils.getAttributeValue(item, attribute);
-        return Array.isArray(value) ? value[0] : value;
-    }
-    getSum(items, attribute) {
-        let sum = 0;
-        items.forEach((item) => {
-            sum += this.getValueFromAttribute(item, attribute).value;
-        });
-        return sum;
+        return distinctValues.map((obj) => ({
+            ...obj,
+            value: AggregationUtils.getAggregatedValueForOperation(operation, obj.values)
+        }));
     }
-    getMin(items, attribute) {
-        const result = items.reduce((prev, curr) => {
-            const prevValue = this.getValueFromAttribute(prev, attribute).value;
-            const currValue = this.getValueFromAttribute(curr, attribute).value;
-            return prevValue < currValue ? prev : curr;
-        });
-        return this.getValueFromAttribute(result, attribute).value;
+    static getKeyValueForTimeInterval(key, interval) {
+        const date = new Date(key);
+        switch (interval) {
+            case 'second':
+                return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()).toISOString();
+            case 'minute':
+                return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes()).toISOString();
+            case 'hour':
+                return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours()).toISOString();
+            case 'day':
+                return new Date(date.getFullYear(), date.getMonth(), date.getDate()).toISOString();
+            case 'week':
+                const daysToSubtract = (7 + date.getUTCDay()) % 7;
+                date.setUTCDate(date.getUTCDate() - daysToSubtract);
+                return date.toISOString();
+            case 'quarter':
+                const quarterStartMonths = [0, 3, 6, 9]; // January, April, July, October
+                const quarter = Math.floor(date.getUTCMonth() / 3);
+                const year = date.getUTCFullYear();
+                const startOfQuarter = new Date(Date.UTC(year, quarterStartMonths[quarter], 1, 0, 0, 0, 0));
+                return startOfQuarter.toISOString();
+            case 'year':
+                return new Date(new Date(key).getFullYear(), 0, 1).toISOString();
+            default:
+                return date.toISOString();
+        }
     }
-    getMax(items, attribute) {
-        const result = items.reduce((prev, curr) => {
-            const prevValue = this.getValueFromAttribute(prev, attribute).value;
-            const currValue = this.getValueFromAttribute(curr, attribute).value;
-            return prevValue > currValue ? prev : curr;
-        });
-        return this.getValueFromAttribute(result, attribute).value;
+    static filterItems(items, filters) {
+        let filtersByAttribute = filters
+            .map((filter) => filter.attributes.map((attribute) => ({
+            ...filter,
+            attribute: attribute.id,
+            attributes: undefined
+        })))
+            .flat();
+        return filters.length > 0
+            ? [
+                ...new Set(filtersByAttribute
+                    .map((filter) => items.filter((item) => this.doesItemValuePassFilter(item, filter.attribute, filter.operator, filter.value)))
+                    .flat())
+            ]
+            : items;
+    }
+    static doesItemValuePassFilter(item, attribute, operator, filterValue) {
+        let value = AggregationUtils.getValueFromAttribute(item, attribute)?.value;
+        let date1, date2;
+        console.log(operator);
+        switch (operator) {
+            case 'EQUALS':
+                return value === filterValue;
+            case 'NOT_EQUALS':
+                return value !== filterValue;
+            case 'CONTAINS':
+                return value.includes(filterValue);
+            case 'START_WITH':
+                return value.startsWith(filterValue);
+            case 'END_WITH':
+                return value.endsWith(filterValue);
+            case 'GREATER_THAN':
+                if (typeof filterValue === 'number') {
+                    return value > filterValue;
+                }
+                else if (typeof filterValue === 'string') {
+                    return new Date(value) > new Date(filterValue);
+                }
+                else {
+                    return false;
+                }
+            case 'LOWER_THAN':
+                if (typeof filterValue === 'number') {
+                    return value < filterValue;
+                }
+                else if (typeof filterValue === 'string') {
+                    return new Date(value) < new Date(filterValue);
+                }
+                else {
+                    return false;
+                }
+            case 'INSIDE':
+                [date1, date2] = [
+                    new Date(filterValue.split(',')[0]),
+                    new Date(filterValue.split(',')[1])
+                ];
+                return new Date(value) > new Date(date1) && new Date(value) < new Date(date2);
+            case 'OUTSIDE':
+                [date1, date2] = [
+                    new Date(filterValue.split(',')[0]),
+                    new Date(filterValue.split(',')[1])
+                ];
+                return new Date(value) < new Date(date1) && new Date(value) > new Date(date2);
+            default:
+                return true;
+        }
     }
-    getAverage(items, attribute) {
-        const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value);
-        return allValues.reduce((acc, val) => acc + val, 0) / allValues.length;
+}
+
+class PryFrontendAggregationService extends PryAggregationService {
+    constructor(store) {
+        super();
+        this.store = store;
     }
-    getDistinct(items, attribute) {
-        return [...new Set(items.map((item) => this.getValueFromAttribute(item, attribute).value))].length;
+    aggregate(datasources, options) {
+        return combineLatest([
+            this.store.select(DashboardSelectors.resultSets),
+            this.store.select(ClassSelectors.classes),
+            this.store.select(DashboardSelectors.filters)
+        ]).pipe(map(([resultSets, classes, filters]) => {
+            const resultSet = AggregationUtils.getChartDatasourceResultSet(datasources, resultSets);
+            let items = Object.keys(resultSet.items)
+                .map((classId) => resultSet.items[classId])
+                .reduce((prev, curr) => [...prev, ...curr], []);
+            items = AggregationUtils.filterItems(items, filters);
+            return this.getAggregationResult(options, classes, items);
+        }));
     }
-    getQuartile(items, attribute, q) {
-        const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value);
-        const allValuesSorted = allValues.sort((a, b) => a - b);
-        let pos = (allValuesSorted.length - 1) * q;
-        if (pos % 1 === 0) {
-            return allValuesSorted[pos];
+    getAggregationResult(options, classes, items) {
+        const [abscissa, ordinate] = [
+            AggregationUtils.getAxisAttribute(classes, options, 'abscissa') ?? '',
+            AggregationUtils.getAxisAttribute(classes, options, 'ordinate') ?? ''
+        ];
+        const aggregationResult = {
+            operation: options.ordinate.operation,
+            values: []
+        };
+        if (!options.groupBy) {
+            if (!!options.ordinate.operation)
+                console.warn('no ordinate operation selected');
+            aggregationResult.values = this.getChartDataBasedOnOperation(items, options.ordinate.operation, abscissa, ordinate, options.abscissa.limit);
+            console.log(aggregationResult.values);
         }
-        pos = Math.floor(pos);
-        if (allValuesSorted[pos + 1] !== undefined) {
-            return (allValuesSorted[pos] + allValuesSorted[pos + 1]) / 2;
+        else {
+            const groupByAttribute = classes
+                .map((clazz) => clazz.attributes.find((attr) => attr.id === options.groupBy?.attribute))
+                .find((attr) => !!attr)?.name ?? '';
+            const itemsGrouped = this.getItemsGroupedByAttributeValue(items, groupByAttribute);
+            aggregationResult.values = Object.keys(itemsGrouped).map((key) => ({
+                key,
+                groupBy: this.getChartDataBasedOnOperation(itemsGrouped[key], options.ordinate.operation, abscissa, ordinate, options.abscissa.limit)
+            }));
         }
-        return allValuesSorted[pos];
-    }
-    getPercentile(items, attribute, q) {
-        const allValues = items.map((item) => this.getValueFromAttribute(item, attribute).value);
-        const allValuesSorted = allValues.sort((a, b) => a - b);
-        return ((100 * allValuesSorted.reduce((acc, v) => acc + (v < q ? 1 : 0) + (v === q ? 0.5 : 0), 0)) /
-            allValuesSorted.length);
+        return aggregationResult;
     }
-    formatByLimit(data, limit) {
-        if (!limit.isTimeLimit) {
-            data
-                .sort((a, b) => (limit.order === 'asc' ? (a.value > b.value ? 1 : -1) : a.value < b.value ? 1 : -1))
-                .splice(limit.at);
-            return data;
-        }
-        return data;
+    getItemsGroupedByAttributeValue(items, attribute) {
+        if (attribute === '')
+            console.warn('groupBy attribute not found');
+        let distinctValues = {};
+        items.forEach((item) => {
+            let value = AggregationUtils.getValueFromAttribute(item, attribute)?.value;
+            if (!!value)
+                distinctValues[value] = [...(distinctValues[value] ?? []), item];
+        });
+        return distinctValues;
+    }
+    // get { key, value } object list that will be our data to show in the chart
+    getChartDataBasedOnOperation(items, operation, abscissa, ordinate, limit) {
+        if (abscissa === '' || ordinate === '')
+            console.warn('abscissa or ordinate attribute not found');
+        const groupByAbscissa = this.getItemsGroupedByAttributeValue(items, abscissa);
+        let result = [
+            ...Object.keys(groupByAbscissa).map((abscissaAttribute) => {
+                console.log(AggregationUtils.getAggregatedValue(operation, groupByAbscissa, abscissaAttribute, ordinate ?? ''));
+                return {
+                    key: +abscissaAttribute || abscissaAttribute,
+                    value: AggregationUtils.getAggregatedValue(operation, groupByAbscissa, abscissaAttribute, ordinate ?? '')
+                };
+            })
+        ];
+        if (limit)
+            result = AggregationUtils.formatByLimit(result, limit, operation);
+        return result;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryFrontendAggregationService, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: PryFrontendAggregationService, providedIn: 'root' }); }