@c8y/ngx-components 1021.13.3 → 1021.22.0

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-view/datapoints-table-view.service.mjs

@@ -0,0 +1,430 @@
+import { Injectable } from '@angular/core';
+import { MeasurementService } from '@c8y/client';
+import { TIME_RANGE_INTERVAL_UNITS_VALUES } from '@c8y/ngx-components/datapoints-export-selector';
+import { DURATION_OPTIONS } from '../datapoints-table-widget.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@c8y/client";
+function mapToSourceValueObject([key, value]) {
+    return { key, value };
+}
+export class DatapointsTableViewService {
+    constructor(measurementService) {
+        this.measurementService = measurementService;
+    }
+    /**
+     * Filters out inactive data points from the given array.
+     *
+     * @param datapoints - The array of data points to filter.
+     * @returns An array of data points that are active.
+     */
+    filterOutInactiveDatapoints(datapoints) {
+        return datapoints.filter((datapoint) => datapoint.__active);
+    }
+    hasMultipleDatapoints(datapoints) {
+        const ids = datapoints.map(dp => dp.__target.id);
+        return ids.length > 1;
+    }
+    /**
+     * Returns a map of active data points device IDs with their corresponding series.
+     *
+     * Example output:
+     * ```typescript
+     * new Map([
+     *   [
+     *     "844657202",
+     *     [
+     *       "c8y_Temperature.T"
+     *     ]
+     *   ],
+     *   [
+     *     "32666427",
+     *     [
+     *       "c8y_Battery.Battery"
+     *     ]
+     *   ]
+     * ]);
+     * ```
+     * @param datapoints - An array of data points.
+     * @returns A map where the key is the data point ID and the value is an array of data point series.
+     */
+    groupSeriesByDeviceId(activeDatapoints) {
+        return activeDatapoints.reduce((map, { fragment, series, __target: { id } }) => {
+            const value = `${fragment}.${series}`;
+            const existingValue = map.get(id) ?? [];
+            map.set(id, [...existingValue, value]);
+            return map;
+        }, new Map());
+    }
+    /**
+     * Retrieves the active data points series data and returns it as a map.
+     *
+     * @param datapointsValuesDataMap - A map of data point sources with their associated series.
+     * @param config - The configuration of the data points table.
+     * @param roundSeconds - Whether to round the seconds or not.
+     *                       If true, the seconds will be rounded to 0.
+     *                       If false, the seconds will be displayed as they are.
+     * @returns A Promise that resolves to a Map object with data point IDs as keys and DataObject as values or undefined when all series has forbidden access.
+     */
+    async getAllActiveSeriesDataMap(datapointsValuesDataMap, config, roundSeconds) {
+        const promises = Array.from(datapointsValuesDataMap).map(async ([source, series]) => {
+            const params = {
+                dateFrom: config.dateFrom,
+                dateTo: config.dateTo,
+                source,
+                series,
+                aggregationType: config.aggregation
+            };
+            // TODO: consider adding a cache mechanism -> MTM-59233
+            const { data, res } = await this.loadSeriesData(params, roundSeconds);
+            return { source, data, res };
+        });
+        const results = await Promise.all(promises);
+        const allSeriesHasForbiddenAccess = results.every(item => item.res?.status === 403);
+        if (allSeriesHasForbiddenAccess) {
+            throw new Error('Access forbidden: All series have a 403 status code');
+        }
+        const filteredResults = this.filterOutElementsWithForbiddenResponses(results);
+        const resultMap = new Map();
+        filteredResults.forEach(result => resultMap.set(result.source, result.data));
+        return resultMap;
+    }
+    /**
+     * Asynchronously loads series data based on the provided parameters.
+     *
+     * This method constructs a filter for retrieving series data within a specified date range,
+     * from a specific source, and optionally applying an aggregation type.
+     *
+     * @param params - The parameters for loading series data, including date range, source, series names, and aggregation type.
+     * @param roundSeconds - Indicates whether to round the seconds in the date range to the nearest whole number.
+     * @returns A promise that resolves to series data wrapped in result object.
+     */
+    // TODO: same method as in the datapoints-export-selector service, when integrating with it (MTM-59689), remove this method and use the one from the service
+    async loadSeriesData(params, roundSeconds) {
+        const { dateFrom, dateTo, source, series, aggregationType } = params;
+        const from = this.adjustDate(dateFrom, 0, roundSeconds);
+        const to = this.adjustDate(dateTo, 0, roundSeconds);
+        const filter = {
+            dateFrom: from,
+            dateTo: to,
+            source: source,
+            revert: true
+        };
+        if (aggregationType) {
+            filter.aggregationType = aggregationType;
+        }
+        // TODO: it is a temporal workaround for a bug in the backend,
+        // where the series with more than one dot are impossible to retrieve:
+        // https://cumulocity.atlassian.net/browse/MTM-59277
+        const hasMoreThanOneDot = series.some(s => s.split('.').length > 2);
+        if (!hasMoreThanOneDot) {
+            filter.series = series;
+        }
+        return await this.measurementService.listSeries(filter);
+    }
+    // TODO: same method as in the datapoints-export-selector service, when integrating with it (MTM-59689), remove this method and use the one from the service
+    // Integration task: MTM-60221
+    // TODO: Compare implementations.
+    /**
+     * Adjusts the given date by adding the specified number of minutes and setting seconds to 0.
+     *
+     * @param date - The date to be adjusted in string format.
+     * @param minutes - The number of minutes to add to the date.
+     * @param roundSeconds - Whether to round the seconds or not.
+     *                       If true, the seconds will be rounded to 0.
+     *                       If false, the seconds will be displayed as they are.
+     * @returns The adjusted date in ISO string format.
+     */
+    adjustDate(date, minutes, roundSeconds = true) {
+        const dateTime = new Date(date);
+        if (isNaN(dateTime.getTime())) {
+            throw new Error('Invalid date');
+        }
+        dateTime.setUTCMinutes(dateTime.getUTCMinutes() + minutes);
+        if (roundSeconds) {
+            dateTime.setUTCSeconds(0, 0);
+        }
+        return dateTime.toISOString();
+    }
+    /**
+     * Creates an array of DatapointsWithValues based on the provided datapoints and datapointsSeriesDataMap.
+     *
+     * Finds an index of a current data point within series object and based on that index filters values array.
+     *
+     * @param datapoints - An array of data points.
+     * @param datapointsSeriesDataMap - A map containing series data for data points.
+     * @returns An array of DatapointsWithValues.
+     */
+    getDatapointsWithValues(datapoints, datapointsSeriesDataMap) {
+        return datapoints.map((dp) => {
+            const seriesData = datapointsSeriesDataMap.get(dp.__target.id);
+            if (!seriesData) {
+                return { ...dp, values: {} };
+            }
+            // Find an index of a corresponding datapoint data, within series object.
+            const datapointSeriesArrayIndex = seriesData.series.findIndex(s => s.name === dp.series && s.type === dp.fragment);
+            const valuesFilteredByDatapointSeriesArrayIndex = Object.fromEntries(Object.entries(seriesData.values).map(([key, arr]) => [
+                key,
+                arr.filter((_, index) => index === datapointSeriesArrayIndex)
+            ]));
+            return {
+                ...dp,
+                seriesUnit: seriesData.series[datapointSeriesArrayIndex]?.unit,
+                values: valuesFilteredByDatapointSeriesArrayIndex
+            };
+        });
+    }
+    /**
+     * Creates the column headers for the devices in the data points table.
+     *
+     * @param datapointsWithValues - An array of data points.
+     * @returns An array of column headers for the devices.
+     */
+    getColumnHeaders(datapointsWithValues) {
+        return datapointsWithValues.map(({ __target: { name }, label, renderType, unit }) => {
+            return { deviceName: name, label, renderType, unit };
+        });
+    }
+    mapDatapointsWithValuesToList(datapointsWithValues) {
+        return datapointsWithValues.flatMap(dp => {
+            if (!dp.values) {
+                return [];
+            }
+            return Object.entries(dp.values).flatMap(([date, valuesArray]) => {
+                const value = this.findMinMaxValues(valuesArray);
+                if (value == null) {
+                    return [];
+                }
+                return [
+                    {
+                        dateAndTime: date,
+                        deviceName: dp.__target.name,
+                        fragment: dp.fragment,
+                        label: dp.label,
+                        redRangeMax: dp.redRangeMax,
+                        redRangeMin: dp.redRangeMin,
+                        renderType: dp.renderType,
+                        series: dp.series,
+                        value: value,
+                        yellowRangeMax: dp.yellowRangeMax,
+                        yellowRangeMin: dp.yellowRangeMin
+                    }
+                ];
+            });
+        });
+    }
+    /**
+     * Finds the overall minimum and maximum values from an array of objects containing 'min' and 'max' properties.
+     *
+     * If the array contains only one object, that object's 'min' and 'max' values will be returned.
+     *
+     * @param valuesArray - An array with objects, where each contains 'min' and 'max' properties.
+     * @returns An object with the smallest 'min' and largest 'max' values found in the array.
+     *
+     * @example
+     * const values = [
+     *   { min: 1, max: 10 }
+     * ];
+     *
+     * const result = findMinMaxValues(values);
+     * // result is { min: 1, max: 10 }
+     */
+    findMinMaxValues(valuesArray) {
+        const validItems = valuesArray.filter((item) => item && item.min != null && item.max != null);
+        if (validItems.length === 0) {
+            return null;
+        }
+        const initialValue = { min: validItems[0].min, max: validItems[0].max };
+        return validItems.reduce((acc, item) => ({
+            min: Math.min(acc.min, item.min),
+            max: Math.max(acc.max, item.max)
+        }), initialValue);
+    }
+    /**
+     * Groups a list of data points by date and device, based on given references.
+     *
+     * @param dataList - The list of data points to be grouped.
+     * @param references - The column headers that serve as references for grouping.
+     * @returns An array of grouped data points, where each group corresponds to a unique date and device.
+     */
+    groupByDateAndDevice(dataList, references) {
+        const map = this.generateDataPointMap(dataList, references);
+        return this.mergeDatapoints(map);
+    }
+    /**
+     * Generates and populates a map with data points.
+     *
+     * This function processes the provided data points and organizes them into a map structure
+     * where each key is a unique combination of date and device identifiers, and the value is an
+     * array of data points (or null values) associated with that key. This structured data is then
+     * used in the data point table to render the data appropriately.
+     *
+     * @param dataList - The list of data point table items to be processed.
+     * @param columnsHeadersReferences - The list of column headers used to determine the order and structure of the map values.
+     * @returns A map where the key is a datapoint identifier containing the date and device name, and the value is an array of data point table items or null.
+     */
+    generateDataPointMap(dataList, columnsHeadersReferences) {
+        // Map to store the data points indexed by a unique identifier.
+        const map = new Map();
+        dataList.forEach(obj => {
+            // Generate a unique identifier for each data point using the date and device name.
+            const dateKey = this.toISOFormat(obj.dateAndTime);
+            const datapointIdentifier = `${dateKey}_${obj.deviceName}`;
+            // Initialize the map entry if it does not exist with a unique identifier.
+            if (!map.has(datapointIdentifier)) {
+                map.set(datapointIdentifier, Array(columnsHeadersReferences.length).fill(null));
+            }
+            // Find the index of the reference that matches the current data point.
+            const matchingColumnIndex = columnsHeadersReferences.findIndex(ref => ref.deviceName === obj.deviceName && ref.label === obj.label);
+            // Update the map entry with the data point.
+            const tableItem = map.get(datapointIdentifier);
+            if (tableItem) {
+                tableItem[matchingColumnIndex] = { ...obj };
+            }
+        });
+        return map;
+    }
+    /**
+     * Merges the data points from the given map into an array of grouped data point table items.
+     *
+     * @param map - The map containing the data points to be merged.
+     * @returns An array of grouped data point table items.
+     */
+    mergeDatapoints(map) {
+        const mergedData = [];
+        map.forEach((values, datapointIdentifier) => {
+            const [dateKey, deviceName] = datapointIdentifier.split('_');
+            const validDataPoint = values.some(item => item && Object.keys(item.value).length > 0);
+            if (validDataPoint) {
+                mergedData.push({
+                    dateAndTime: dateKey,
+                    deviceName: deviceName,
+                    rowItems: values.map(item => (item ? { ...item } : null))
+                });
+            }
+        });
+        return mergedData;
+    }
+    sortDataByDateDescending(data) {
+        return data.sort((a, b) => new Date(b.dateAndTime).getTime() - new Date(a.dateAndTime).getTime());
+    }
+    /**
+     * Prepares the updated time range based on the selected interval.
+     *
+     * In case of a 'custom' interval or no quantity, the original date range is returned.
+     *
+     * @param interval - The selected interval type.
+     * @returns An object containing the `dateFrom` and `dateTo` in ISO string format.
+     */
+    prepareTimeRange(interval, dateFromInput, dateToInput) {
+        if (!interval || interval === TIME_RANGE_INTERVAL_UNITS_VALUES.custom) {
+            return { dateFrom: dateFromInput, dateTo: dateToInput };
+        }
+        const selected = DURATION_OPTIONS.find(selectedDuration => selectedDuration.id === interval);
+        if (!selected?.amount) {
+            return { dateFrom: dateFromInput, dateTo: dateToInput };
+        }
+        const now = new Date();
+        return {
+            dateFrom: this.subtractTime(now, selected.amount, selected.unit).toISOString(),
+            dateTo: now.toISOString()
+        };
+    }
+    /**
+     * Subtracts an amount of time from a given date.
+     *
+     * @param date - The original date.
+     * @param amount - The amount of time units to subtract.
+     * @param unit - The unit of time to subtract (e.g., minutes, hours, days, weeks, months).
+     * @returns A new date with the specified time subtracted.
+     */
+    subtractTime(date, amount, unit) {
+        const newDate = new Date(date);
+        switch (unit) {
+            case TIME_RANGE_INTERVAL_UNITS_VALUES.minutes:
+                newDate.setUTCMinutes(newDate.getUTCMinutes() - amount);
+                break;
+            case TIME_RANGE_INTERVAL_UNITS_VALUES.hours:
+                newDate.setUTCHours(newDate.getUTCHours() - amount);
+                break;
+            case TIME_RANGE_INTERVAL_UNITS_VALUES.days:
+                newDate.setUTCDate(newDate.getUTCDate() - amount);
+                break;
+            case TIME_RANGE_INTERVAL_UNITS_VALUES.weeks:
+                newDate.setUTCDate(newDate.getUTCDate() - amount * 7);
+                break;
+            case TIME_RANGE_INTERVAL_UNITS_VALUES.months:
+                this.subtractMonthsAndAdjustDay(newDate, amount);
+                break;
+        }
+        return newDate;
+    }
+    getSeriesWithoutPermissionToRead(activeDatapointsSeriesData, activeDatapointsIdsWithSeries) {
+        if (!activeDatapointsSeriesData) {
+            // Returns all activeDatapointsIdsWithSeries entries if activeDatapointsSeriesData is undefined.
+            // It means that the user does not have permission to see any of the selected datapoints data.
+            return Array.from(activeDatapointsIdsWithSeries, mapToSourceValueObject);
+        }
+        const availableSources = new Set(activeDatapointsSeriesData.keys());
+        return Array.from(activeDatapointsIdsWithSeries)
+            .filter(([source]) => !availableSources.has(source))
+            .map(mapToSourceValueObject);
+    }
+    /**
+     * Converts a date string to ISO format.
+     *
+     * @param dateStr - The date string to convert.
+     * @returns The ISO format of the given date string.
+     */
+    toISOFormat(dateStr) {
+        return new Date(dateStr).toISOString();
+    }
+    filterOutElementsWithForbiddenResponses(seriesDataWithResponse) {
+        return seriesDataWithResponse.filter(item => {
+            return !(item.res?.status === 403);
+        });
+    }
+    subtractMonthsAndAdjustDay(date, monthsToSubtract) {
+        const currentMonth = date.getUTCMonth();
+        const expectedTargetMonth = this.calculateTargetMonth(currentMonth, monthsToSubtract);
+        date.setUTCMonth(currentMonth - monthsToSubtract);
+        const actualMonth = date.getUTCMonth();
+        const dayDoesNotExistInTargetMonth = actualMonth !== expectedTargetMonth;
+        if (dayDoesNotExistInTargetMonth) {
+            this.setToLastDayOfPreviousMonth(date);
+        }
+    }
+    /**
+     * Calculates the target month number (0-11) after subtracting months from the current month.
+     * Handles negative month numbers by normalizing them to the valid 0-11 range.
+     *
+     * Examples:
+     * - January(0) - 1 month = December(11)
+     * - March(2) - 4 months = November(10)
+     * - December(11) - 1 month = November(10)
+     *
+     * @param currentMonth - Current month (0-11, where 0 is January)
+     * @param monthsToSubtract - Number of months to subtract
+     * @returns Normalized month number in range 0-11
+     */
+    calculateTargetMonth(currentMonth, monthsToSubtract) {
+        return (currentMonth - monthsToSubtract + 12) % 12;
+    }
+    /**
+     * Sets the date to the last day of the previous month.
+     * Using 0 as dateValue makes JavaScript automatically calculate
+     * last day of previous month, per JavaScript Date API behavior.
+     * @param date - Date to modify
+     */
+    setToLastDayOfPreviousMonth(date) {
+        date.setUTCDate(0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsTableViewService, deps: [{ token: i1.MeasurementService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsTableViewService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsTableViewService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.MeasurementService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datapoints-table-view.service.js","sourceRoot":"","sources":["../../../../../../widgets/implementations/datapoints-table/datapoints-table-view/datapoints-table-view.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAmC,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AAEnG,OAAO,EAIL,gCAAgC,EAEjC,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACL,gBAAgB,EAajB,MAAM,kCAAkC,CAAC;;;AAE1C,SAAS,sBAAsB,CAAC,CAAC,GAAG,EAAE,KAAK,CAAuB;IAIhE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;AACxB,CAAC;AAKD,MAAM,OAAO,0BAA0B;IACrC,YAAoB,kBAAsC;QAAtC,uBAAkB,GAAlB,kBAAkB,CAAoB;IAAG,CAAC;IAE9D;;;;;OAKG;IACH,2BAA2B,CAAC,UAAwB;QAClD,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,SAAqB,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC;IAED,qBAAqB,CAAC,UAAwB;QAC5C,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACjD,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;IACxB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,qBAAqB,CAAC,gBAA8B;QAClD,OAAO,gBAAgB,CAAC,MAAM,CAC5B,CAAC,GAA4B,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAc,EAAE,EAAE;YACnF,MAAM,KAAK,GAAG,GAAG,QAAQ,IAAI,MAAM,EAAE,CAAC;YACtC,MAAM,aAAa,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;YACxC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC;YACvC,OAAO,GAAG,CAAC;QACb,CAAC,EACD,IAAI,GAAG,EAAsB,CAC9B,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,yBAAyB,CAC7B,uBAAgD,EAChD,MAA6B,EAC7B,YAAqB;QAErB,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE;YAClF,MAAM,MAAM,GAAkB;gBAC5B,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,MAAM;gBACN,MAAM;gBACN,eAAe,EAAE,MAAM,CAAC,WAA8B;aACvD,CAAC;YACF,uDAAuD;YACvD,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAqB,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAExF,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,MAAM,OAAO,GAA6B,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAEtE,MAAM,2BAA2B,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC,CAAC;QACpF,IAAI,2BAA2B,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,MAAM,eAAe,GACnB,IAAI,CAAC,uCAAuC,CAAC,OAAO,CAAC,CAAC;QAExD,MAAM,SAAS,GAA4B,IAAI,GAAG,EAA4B,CAAC;QAC/E,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAE7E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;;;;OASG;IACH,4JAA4J;IAC5J,KAAK,CAAC,cAAc,CAAC,MAAqB,EAAE,YAAqB;QAC/D,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,CAAC;QACrE,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC;QACxD,MAAM,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC;QAEpD,MAAM,MAAM,GAAkB;YAC5B,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,EAAE;YACV,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,IAAI;SACb,CAAC;QAEF,IAAI,eAAe,EAAE,CAAC;YACpB,MAAM,CAAC,eAAe,GAAG,eAAe,CAAC;QAC3C,CAAC;QAED,8DAA8D;QAC9D,sEAAsE;QACtE,oDAAoD;QACpD,MAAM,iBAAiB,GAAI,MAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAClF,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;QACzB,CAAC;QAED,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC1D,CAAC;IAED,4JAA4J;IAC5J,8BAA8B;IAC9B,iCAAiC;IACjC;;;;;;;;;OASG;IACH,UAAU,CAAC,IAAmB,EAAE,OAAe,EAAE,YAAY,GAAG,IAAI;QAClE,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,KAAK,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC;QAClC,CAAC;QAED,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,OAAO,CAAC,CAAC;QAC3D,IAAI,YAAY,EAAE,CAAC;YACjB,QAAQ,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,QAAQ,CAAC,WAAW,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;;;OAQG;IACH,uBAAuB,CACrB,UAAwB,EACxB,uBAAgD;QAEhD,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,EAAc,EAAE,EAAE;YACvC,MAAM,UAAU,GAAY,uBAAuB,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YAExE,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,OAAO,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;YAC/B,CAAC;YAED,yEAAyE;YACzE,MAAM,yBAAyB,GAAG,UAAU,CAAC,MAAM,CAAC,SAAS,CAC3D,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,QAAQ,CACpD,CAAC;YAEF,MAAM,yCAAyC,GAAsB,MAAM,CAAC,WAAW,CACrF,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;gBACpD,GAAG;gBACH,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,yBAAyB,CAAC;aAC9D,CAAC,CACH,CAAC;YAEF,OAAO;gBACL,GAAG,EAAE;gBACL,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC,yBAAyB,CAAC,EAAE,IAAI;gBAC9D,MAAM,EAAE,yCAAyC;aAClD,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,oBAAkC;QACjD,OAAO,oBAAoB,CAAC,GAAG,CAC7B,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,EAAqB,EAAE;YACrE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;QACvD,CAAC,CACF,CAAC;IACJ,CAAC;IAED,6BAA6B,CAAC,oBAA2C;QACvE,OAAO,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;YACvC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC;gBACf,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,OAAO,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE,EAAE;gBAC/D,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;gBACjD,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;oBAClB,OAAO,EAAE,CAAC;gBACZ,CAAC;gBACD,OAAO;oBACL;wBACE,WAAW,EAAE,IAAI;wBACjB,UAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI;wBAC5B,QAAQ,EAAE,EAAE,CAAC,QAAQ;wBACrB,KAAK,EAAE,EAAE,CAAC,KAAK;wBACf,WAAW,EAAE,EAAE,CAAC,WAAW;wBAC3B,WAAW,EAAE,EAAE,CAAC,WAAW;wBAC3B,UAAU,EAAE,EAAE,CAAC,UAAU;wBACzB,MAAM,EAAE,EAAE,CAAC,MAAM;wBACjB,KAAK,EAAE,KAAK;wBACZ,cAAc,EAAE,EAAE,CAAC,cAAc;wBACjC,cAAc,EAAE,EAAE,CAAC,cAAc;qBAClC;iBACF,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,WAA2B;QAC1C,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,CACnC,CAAC,IAAI,EAAiB,EAAE,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,IAAI,IAAI,CAAC,GAAG,IAAI,IAAI,CACtE,CAAC;QAEF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,YAAY,GAAU,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAE/E,OAAO,UAAU,CAAC,MAAM,CACtB,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;YACd,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;YAChC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;SACjC,CAAC,EACF,YAAY,CACb,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,oBAAoB,CAClB,QAA8B,EAC9B,UAA+B;QAE/B,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAC5D,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;OAWG;IACH,oBAAoB,CAClB,QAA8B,EAC9B,wBAA6C;QAE7C,+DAA+D;QAC/D,MAAM,GAAG,GAAuB,IAAI,GAAG,EAAuD,CAAC;QAE/F,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACrB,mFAAmF;YACnF,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YAClD,MAAM,mBAAmB,GAAyB,GAAG,OAAO,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC;YAEjF,0EAA0E;YAC1E,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,EAAE,CAAC;gBAClC,GAAG,CAAC,GAAG,CAAC,mBAAmB,EAAE,KAAK,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YAClF,CAAC;YAED,uEAAuE;YACvE,MAAM,mBAAmB,GAAG,wBAAwB,CAAC,SAAS,CAC5D,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,KAAK,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,KAAK,CACpE,CAAC;YAEF,4CAA4C;YAC5C,MAAM,SAAS,GAAyB,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;YACrE,IAAI,SAAS,EAAE,CAAC;gBACd,SAAS,CAAC,mBAAmB,CAAC,GAAG,EAAE,GAAG,GAAG,EAAE,CAAC;YAC9C,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,GAAuB;QACrC,MAAM,UAAU,GAAgC,EAAE,CAAC;QAEnD,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,mBAAmB,EAAE,EAAE;YAC1C,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC7D,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAEvF,IAAI,cAAc,EAAE,CAAC;gBACnB,UAAU,CAAC,IAAI,CAAC;oBACd,WAAW,EAAE,OAAO;oBACpB,UAAU,EAAE,UAAU;oBACtB,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;iBAC1D,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,wBAAwB,CAAC,IAAiC;QACxD,OAAO,IAAI,CAAC,IAAI,CACd,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE,CAChF,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,gBAAgB,CACd,QAA2B,EAC3B,aAAqB,EACrB,WAAmB;QAEnB,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,gCAAgC,CAAC,MAAM,EAAE,CAAC;YACtE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QAC1D,CAAC;QAED,MAAM,QAAQ,GAAa,gBAAgB,CAAC,IAAI,CAC9C,gBAAgB,CAAC,EAAE,CAAC,gBAAgB,CAAC,EAAE,KAAK,QAAQ,CACrD,CAAC;QAEF,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;YACtB,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QAC1D,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;QAEvB,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE;YAC9E,MAAM,EAAE,GAAG,CAAC,WAAW,EAAE;SAC1B,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,IAAU,EAAE,MAAc,EAAE,IAAY;QACnD,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;QAE/B,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,gCAAgC,CAAC,OAAO;gBAC3C,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,MAAM,CAAC,CAAC;gBACxD,MAAM;YACR,KAAK,gCAAgC,CAAC,KAAK;gBACzC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,CAAC;gBACpD,MAAM;YACR,KAAK,gCAAgC,CAAC,IAAI;gBACxC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,MAAM,CAAC,CAAC;gBAClD,MAAM;YACR,KAAK,gCAAgC,CAAC,KAAK;gBACzC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC;gBACtD,MAAM;YACR,KAAK,gCAAgC,CAAC,MAAM;gBAC1C,IAAI,CAAC,0BAA0B,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBACjD,MAAM;QACV,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,gCAAgC,CAC9B,0BAAqE,EACrE,6BAAsD;QAEtD,IAAI,CAAC,0BAA0B,EAAE,CAAC;YAChC,gGAAgG;YAChG,8FAA8F;YAC9F,OAAO,KAAK,CAAC,IAAI,CAAC,6BAA6B,EAAE,sBAAsB,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,0BAA0B,CAAC,IAAI,EAAE,CAAC,CAAC;QAEpE,OAAO,KAAK,CAAC,IAAI,CAAC,6BAA6B,CAAC;aAC7C,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;aACnD,GAAG,CAAC,sBAAsB,CAAC,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACK,WAAW,CAAC,OAAe;QACjC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;IACzC,CAAC;IAEO,uCAAuC,CAC7C,sBAAgD;QAEhD,OAAO,sBAAsB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC1C,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,0BAA0B,CAAC,IAAU,EAAE,gBAAwB;QACrE,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACxC,MAAM,mBAAmB,GAAG,IAAI,CAAC,oBAAoB,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAC;QAEtF,IAAI,CAAC,WAAW,CAAC,YAAY,GAAG,gBAAgB,CAAC,CAAC;QAElD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACvC,MAAM,4BAA4B,GAAG,WAAW,KAAK,mBAAmB,CAAC;QAEzE,IAAI,4BAA4B,EAAE,CAAC;YACjC,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;OAYG;IACK,oBAAoB,CAAC,YAAoB,EAAE,gBAAwB;QACzE,OAAO,CAAC,YAAY,GAAG,gBAAgB,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACK,2BAA2B,CAAC,IAAU;QAC5C,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IACrB,CAAC;8GA9fU,0BAA0B;kHAA1B,0BAA0B,cAFzB,MAAM;;2FAEP,0BAA0B;kBAHtC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { IResult, ISeries, ISeriesFilter, MeasurementService, aggregationType } from '@c8y/client';\nimport { KPIDetails } from '@c8y/ngx-components/datapoint-selector';\nimport {\n  DatapointsValuesDataMap,\n  MinMaxValues,\n  SourceId,\n  TIME_RANGE_INTERVAL_UNITS_VALUES,\n  TimeRangeInterval\n} from '@c8y/ngx-components/datapoints-export-selector';\nimport {\n  DURATION_OPTIONS,\n  DataPointsTableMap,\n  DatapointTableItem,\n  DatapointTableMapKey,\n  DatapointWithValues,\n  DatapointsSeriesDataMap,\n  DatapointsTableConfig,\n  Duration,\n  GroupedDatapointTableItem,\n  MeasurementRanges,\n  SeriesDataWithResponse,\n  TableColumnHeader,\n  Value\n} from '../datapoints-table-widget.model';\n\nfunction mapToSourceValueObject([key, value]: [SourceId, string[]]): {\n  key: SourceId;\n  value: string[];\n} {\n  return { key, value };\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DatapointsTableViewService {\n  constructor(private measurementService: MeasurementService) {}\n\n  /**\n   * Filters out inactive data points from the given array.\n   *\n   * @param datapoints - The array of data points to filter.\n   * @returns An array of data points that are active.\n   */\n  filterOutInactiveDatapoints(datapoints: KPIDetails[]): KPIDetails[] {\n    return datapoints.filter((datapoint: KPIDetails) => datapoint.__active);\n  }\n\n  hasMultipleDatapoints(datapoints: KPIDetails[]): boolean {\n    const ids = datapoints.map(dp => dp.__target.id);\n    return ids.length > 1;\n  }\n\n  /**\n   * Returns a map of active data points device IDs with their corresponding series.\n   *\n   * Example output:\n   * ```typescript\n   * new Map([\n   *   [\n   *     \"844657202\",\n   *     [\n   *       \"c8y_Temperature.T\"\n   *     ]\n   *   ],\n   *   [\n   *     \"32666427\",\n   *     [\n   *       \"c8y_Battery.Battery\"\n   *     ]\n   *   ]\n   * ]);\n   * ```\n   * @param datapoints - An array of data points.\n   * @returns A map where the key is the data point ID and the value is an array of data point series.\n   */\n  groupSeriesByDeviceId(activeDatapoints: KPIDetails[]): DatapointsValuesDataMap {\n    return activeDatapoints.reduce(\n      (map: DatapointsValuesDataMap, { fragment, series, __target: { id } }: KPIDetails) => {\n        const value = `${fragment}.${series}`;\n        const existingValue = map.get(id) ?? [];\n        map.set(id, [...existingValue, value]);\n        return map;\n      },\n      new Map<SourceId, string[]>()\n    );\n  }\n\n  /**\n   * Retrieves the active data points series data and returns it as a map.\n   *\n   * @param datapointsValuesDataMap - A map of data point sources with their associated series.\n   * @param config - The configuration of the data points table.\n   * @param roundSeconds - Whether to round the seconds or not.\n   *                       If true, the seconds will be rounded to 0.\n   *                       If false, the seconds will be displayed as they are.\n   * @returns A Promise that resolves to a Map object with data point IDs as keys and DataObject as values or undefined when all series has forbidden access.\n   */\n  async getAllActiveSeriesDataMap(\n    datapointsValuesDataMap: DatapointsValuesDataMap,\n    config: DatapointsTableConfig,\n    roundSeconds: boolean\n  ): Promise<Map<string | number, ISeries>> {\n    const promises = Array.from(datapointsValuesDataMap).map(async ([source, series]) => {\n      const params: ISeriesFilter = {\n        dateFrom: config.dateFrom,\n        dateTo: config.dateTo,\n        source,\n        series,\n        aggregationType: config.aggregation as aggregationType\n      };\n      // TODO: consider adding a cache mechanism -> MTM-59233\n      const { data, res }: IResult<ISeries> = await this.loadSeriesData(params, roundSeconds);\n\n      return { source, data, res };\n    });\n\n    const results: SeriesDataWithResponse[] = await Promise.all(promises);\n\n    const allSeriesHasForbiddenAccess = results.every(item => item.res?.status === 403);\n    if (allSeriesHasForbiddenAccess) {\n      throw new Error('Access forbidden: All series have a 403 status code');\n    }\n\n    const filteredResults: SeriesDataWithResponse[] =\n      this.filterOutElementsWithForbiddenResponses(results);\n\n    const resultMap: DatapointsSeriesDataMap = new Map<string | number, ISeries>();\n    filteredResults.forEach(result => resultMap.set(result.source, result.data));\n\n    return resultMap;\n  }\n\n  /**\n   * Asynchronously loads series data based on the provided parameters.\n   *\n   * This method constructs a filter for retrieving series data within a specified date range,\n   * from a specific source, and optionally applying an aggregation type.\n   *\n   * @param params - The parameters for loading series data, including date range, source, series names, and aggregation type.\n   * @param roundSeconds - Indicates whether to round the seconds in the date range to the nearest whole number.\n   * @returns A promise that resolves to series data wrapped in result object.\n   */\n  // TODO: same method as in the datapoints-export-selector service, when integrating with it (MTM-59689), remove this method and use the one from the service\n  async loadSeriesData(params: ISeriesFilter, roundSeconds: boolean): Promise<IResult<ISeries>> {\n    const { dateFrom, dateTo, source, series, aggregationType } = params;\n    const from = this.adjustDate(dateFrom, 0, roundSeconds);\n    const to = this.adjustDate(dateTo, 0, roundSeconds);\n\n    const filter: ISeriesFilter = {\n      dateFrom: from,\n      dateTo: to,\n      source: source,\n      revert: true\n    };\n\n    if (aggregationType) {\n      filter.aggregationType = aggregationType;\n    }\n\n    // TODO: it is a temporal workaround for a bug in the backend,\n    // where the series with more than one dot are impossible to retrieve:\n    // https://cumulocity.atlassian.net/browse/MTM-59277\n    const hasMoreThanOneDot = (series as string[]).some(s => s.split('.').length > 2);\n    if (!hasMoreThanOneDot) {\n      filter.series = series;\n    }\n\n    return await this.measurementService.listSeries(filter);\n  }\n\n  // TODO: same method as in the datapoints-export-selector service, when integrating with it (MTM-59689), remove this method and use the one from the service\n  // Integration task: MTM-60221\n  // TODO: Compare implementations.\n  /**\n   * Adjusts the given date by adding the specified number of minutes and setting seconds to 0.\n   *\n   * @param date - The date to be adjusted in string format.\n   * @param minutes - The number of minutes to add to the date.\n   * @param roundSeconds - Whether to round the seconds or not.\n   *                       If true, the seconds will be rounded to 0.\n   *                       If false, the seconds will be displayed as they are.\n   * @returns The adjusted date in ISO string format.\n   */\n  adjustDate(date: string | Date, minutes: number, roundSeconds = true): string {\n    const dateTime = new Date(date);\n    if (isNaN(dateTime.getTime())) {\n      throw new Error('Invalid date');\n    }\n\n    dateTime.setUTCMinutes(dateTime.getUTCMinutes() + minutes);\n    if (roundSeconds) {\n      dateTime.setUTCSeconds(0, 0);\n    }\n\n    return dateTime.toISOString();\n  }\n\n  /**\n   * Creates an array of DatapointsWithValues based on the provided datapoints and datapointsSeriesDataMap.\n   *\n   * Finds an index of a current data point within series object and based on that index filters values array.\n   *\n   * @param datapoints - An array of data points.\n   * @param datapointsSeriesDataMap - A map containing series data for data points.\n   * @returns An array of DatapointsWithValues.\n   */\n  getDatapointsWithValues(\n    datapoints: KPIDetails[],\n    datapointsSeriesDataMap: DatapointsSeriesDataMap\n  ): DatapointWithValues[] {\n    return datapoints.map((dp: KPIDetails) => {\n      const seriesData: ISeries = datapointsSeriesDataMap.get(dp.__target.id);\n\n      if (!seriesData) {\n        return { ...dp, values: {} };\n      }\n\n      // Find an index of a corresponding datapoint data, within series object.\n      const datapointSeriesArrayIndex = seriesData.series.findIndex(\n        s => s.name === dp.series && s.type === dp.fragment\n      );\n\n      const valuesFilteredByDatapointSeriesArrayIndex: MeasurementRanges = Object.fromEntries(\n        Object.entries(seriesData.values).map(([key, arr]) => [\n          key,\n          arr.filter((_, index) => index === datapointSeriesArrayIndex)\n        ])\n      );\n\n      return {\n        ...dp,\n        seriesUnit: seriesData.series[datapointSeriesArrayIndex]?.unit,\n        values: valuesFilteredByDatapointSeriesArrayIndex\n      };\n    });\n  }\n\n  /**\n   * Creates the column headers for the devices in the data points table.\n   *\n   * @param datapointsWithValues - An array of data points.\n   * @returns An array of column headers for the devices.\n   */\n  getColumnHeaders(datapointsWithValues: KPIDetails[]): TableColumnHeader[] {\n    return datapointsWithValues.map(\n      ({ __target: { name }, label, renderType, unit }): TableColumnHeader => {\n        return { deviceName: name, label, renderType, unit };\n      }\n    );\n  }\n\n  mapDatapointsWithValuesToList(datapointsWithValues: DatapointWithValues[]): DatapointTableItem[] {\n    return datapointsWithValues.flatMap(dp => {\n      if (!dp.values) {\n        return [];\n      }\n      return Object.entries(dp.values).flatMap(([date, valuesArray]) => {\n        const value = this.findMinMaxValues(valuesArray);\n        if (value == null) {\n          return [];\n        }\n        return [\n          {\n            dateAndTime: date,\n            deviceName: dp.__target.name,\n            fragment: dp.fragment,\n            label: dp.label,\n            redRangeMax: dp.redRangeMax,\n            redRangeMin: dp.redRangeMin,\n            renderType: dp.renderType,\n            series: dp.series,\n            value: value,\n            yellowRangeMax: dp.yellowRangeMax,\n            yellowRangeMin: dp.yellowRangeMin\n          }\n        ];\n      });\n    });\n  }\n\n  /**\n   * Finds the overall minimum and maximum values from an array of objects containing 'min' and 'max' properties.\n   *\n   * If the array contains only one object, that object's 'min' and 'max' values will be returned.\n   *\n   * @param valuesArray - An array with objects, where each contains 'min' and 'max' properties.\n   * @returns An object with the smallest 'min' and largest 'max' values found in the array.\n   *\n   * @example\n   * const values = [\n   *   { min: 1, max: 10 }\n   * ];\n   *\n   * const result = findMinMaxValues(values);\n   * // result is { min: 1, max: 10 }\n   */\n  findMinMaxValues(valuesArray: MinMaxValues[]): Value | null {\n    const validItems = valuesArray.filter(\n      (item): item is Value => item && item.min != null && item.max != null\n    );\n\n    if (validItems.length === 0) {\n      return null;\n    }\n\n    const initialValue: Value = { min: validItems[0].min, max: validItems[0].max };\n\n    return validItems.reduce<Value>(\n      (acc, item) => ({\n        min: Math.min(acc.min, item.min),\n        max: Math.max(acc.max, item.max)\n      }),\n      initialValue\n    );\n  }\n\n  /**\n   * Groups a list of data points by date and device, based on given references.\n   *\n   * @param dataList - The list of data points to be grouped.\n   * @param references - The column headers that serve as references for grouping.\n   * @returns An array of grouped data points, where each group corresponds to a unique date and device.\n   */\n  groupByDateAndDevice(\n    dataList: DatapointTableItem[],\n    references: TableColumnHeader[]\n  ): GroupedDatapointTableItem[] {\n    const map = this.generateDataPointMap(dataList, references);\n    return this.mergeDatapoints(map);\n  }\n\n  /**\n   * Generates and populates a map with data points.\n   *\n   * This function processes the provided data points and organizes them into a map structure\n   * where each key is a unique combination of date and device identifiers, and the value is an\n   * array of data points (or null values) associated with that key. This structured data is then\n   * used in the data point table to render the data appropriately.\n   *\n   * @param dataList - The list of data point table items to be processed.\n   * @param columnsHeadersReferences - The list of column headers used to determine the order and structure of the map values.\n   * @returns A map where the key is a datapoint identifier containing the date and device name, and the value is an array of data point table items or null.\n   */\n  generateDataPointMap(\n    dataList: DatapointTableItem[],\n    columnsHeadersReferences: TableColumnHeader[]\n  ): DataPointsTableMap {\n    // Map to store the data points indexed by a unique identifier.\n    const map: DataPointsTableMap = new Map<DatapointTableMapKey, (DatapointTableItem | null)[]>();\n\n    dataList.forEach(obj => {\n      // Generate a unique identifier for each data point using the date and device name.\n      const dateKey = this.toISOFormat(obj.dateAndTime);\n      const datapointIdentifier: DatapointTableMapKey = `${dateKey}_${obj.deviceName}`;\n\n      // Initialize the map entry if it does not exist with a unique identifier.\n      if (!map.has(datapointIdentifier)) {\n        map.set(datapointIdentifier, Array(columnsHeadersReferences.length).fill(null));\n      }\n\n      // Find the index of the reference that matches the current data point.\n      const matchingColumnIndex = columnsHeadersReferences.findIndex(\n        ref => ref.deviceName === obj.deviceName && ref.label === obj.label\n      );\n\n      // Update the map entry with the data point.\n      const tableItem: DatapointTableItem[] = map.get(datapointIdentifier);\n      if (tableItem) {\n        tableItem[matchingColumnIndex] = { ...obj };\n      }\n    });\n\n    return map;\n  }\n\n  /**\n   * Merges the data points from the given map into an array of grouped data point table items.\n   *\n   * @param map - The map containing the data points to be merged.\n   * @returns An array of grouped data point table items.\n   */\n  mergeDatapoints(map: DataPointsTableMap): GroupedDatapointTableItem[] {\n    const mergedData: GroupedDatapointTableItem[] = [];\n\n    map.forEach((values, datapointIdentifier) => {\n      const [dateKey, deviceName] = datapointIdentifier.split('_');\n      const validDataPoint = values.some(item => item && Object.keys(item.value).length > 0);\n\n      if (validDataPoint) {\n        mergedData.push({\n          dateAndTime: dateKey,\n          deviceName: deviceName,\n          rowItems: values.map(item => (item ? { ...item } : null))\n        });\n      }\n    });\n\n    return mergedData;\n  }\n\n  sortDataByDateDescending(data: GroupedDatapointTableItem[]): GroupedDatapointTableItem[] {\n    return data.sort(\n      (a, b) => new Date(b.dateAndTime).getTime() - new Date(a.dateAndTime).getTime()\n    );\n  }\n\n  /**\n   * Prepares the updated time range based on the selected interval.\n   *\n   * In case of a 'custom' interval or no quantity, the original date range is returned.\n   *\n   * @param interval - The selected interval type.\n   * @returns An object containing the `dateFrom` and `dateTo` in ISO string format.\n   */\n  prepareTimeRange(\n    interval: TimeRangeInterval,\n    dateFromInput: string,\n    dateToInput: string\n  ): { dateFrom: string; dateTo: string } {\n    if (!interval || interval === TIME_RANGE_INTERVAL_UNITS_VALUES.custom) {\n      return { dateFrom: dateFromInput, dateTo: dateToInput };\n    }\n\n    const selected: Duration = DURATION_OPTIONS.find(\n      selectedDuration => selectedDuration.id === interval\n    );\n\n    if (!selected?.amount) {\n      return { dateFrom: dateFromInput, dateTo: dateToInput };\n    }\n\n    const now = new Date();\n\n    return {\n      dateFrom: this.subtractTime(now, selected.amount, selected.unit).toISOString(),\n      dateTo: now.toISOString()\n    };\n  }\n\n  /**\n   * Subtracts an amount of time from a given date.\n   *\n   * @param date - The original date.\n   * @param amount - The amount of time units to subtract.\n   * @param unit - The unit of time to subtract (e.g., minutes, hours, days, weeks, months).\n   * @returns A new date with the specified time subtracted.\n   */\n  subtractTime(date: Date, amount: number, unit: string): Date {\n    const newDate = new Date(date);\n\n    switch (unit) {\n      case TIME_RANGE_INTERVAL_UNITS_VALUES.minutes:\n        newDate.setUTCMinutes(newDate.getUTCMinutes() - amount);\n        break;\n      case TIME_RANGE_INTERVAL_UNITS_VALUES.hours:\n        newDate.setUTCHours(newDate.getUTCHours() - amount);\n        break;\n      case TIME_RANGE_INTERVAL_UNITS_VALUES.days:\n        newDate.setUTCDate(newDate.getUTCDate() - amount);\n        break;\n      case TIME_RANGE_INTERVAL_UNITS_VALUES.weeks:\n        newDate.setUTCDate(newDate.getUTCDate() - amount * 7);\n        break;\n      case TIME_RANGE_INTERVAL_UNITS_VALUES.months:\n        this.subtractMonthsAndAdjustDay(newDate, amount);\n        break;\n    }\n    return newDate;\n  }\n\n  getSeriesWithoutPermissionToRead(\n    activeDatapointsSeriesData: Map<string | number, ISeries> | undefined,\n    activeDatapointsIdsWithSeries: DatapointsValuesDataMap\n  ): { key: SourceId; value: string[] }[] {\n    if (!activeDatapointsSeriesData) {\n      // Returns all activeDatapointsIdsWithSeries entries if activeDatapointsSeriesData is undefined.\n      // It means that the user does not have permission to see any of the selected datapoints data.\n      return Array.from(activeDatapointsIdsWithSeries, mapToSourceValueObject);\n    }\n\n    const availableSources = new Set(activeDatapointsSeriesData.keys());\n\n    return Array.from(activeDatapointsIdsWithSeries)\n      .filter(([source]) => !availableSources.has(source))\n      .map(mapToSourceValueObject);\n  }\n\n  /**\n   * Converts a date string to ISO format.\n   *\n   * @param dateStr - The date string to convert.\n   * @returns The ISO format of the given date string.\n   */\n  private toISOFormat(dateStr: string): string {\n    return new Date(dateStr).toISOString();\n  }\n\n  private filterOutElementsWithForbiddenResponses(\n    seriesDataWithResponse: SeriesDataWithResponse[]\n  ): SeriesDataWithResponse[] {\n    return seriesDataWithResponse.filter(item => {\n      return !(item.res?.status === 403);\n    });\n  }\n\n  private subtractMonthsAndAdjustDay(date: Date, monthsToSubtract: number): void {\n    const currentMonth = date.getUTCMonth();\n    const expectedTargetMonth = this.calculateTargetMonth(currentMonth, monthsToSubtract);\n\n    date.setUTCMonth(currentMonth - monthsToSubtract);\n\n    const actualMonth = date.getUTCMonth();\n    const dayDoesNotExistInTargetMonth = actualMonth !== expectedTargetMonth;\n\n    if (dayDoesNotExistInTargetMonth) {\n      this.setToLastDayOfPreviousMonth(date);\n    }\n  }\n\n  /**\n   * Calculates the target month number (0-11) after subtracting months from the current month.\n   * Handles negative month numbers by normalizing them to the valid 0-11 range.\n   *\n   * Examples:\n   * - January(0) - 1 month = December(11)\n   * - March(2) - 4 months = November(10)\n   * - December(11) - 1 month = November(10)\n   *\n   * @param currentMonth - Current month (0-11, where 0 is January)\n   * @param monthsToSubtract - Number of months to subtract\n   * @returns Normalized month number in range 0-11\n   */\n  private calculateTargetMonth(currentMonth: number, monthsToSubtract: number): number {\n    return (currentMonth - monthsToSubtract + 12) % 12;\n  }\n\n  /**\n   * Sets the date to the last day of the previous month.\n   * Using 0 as dateValue makes JavaScript automatically calculate\n   * last day of previous month, per JavaScript Date API behavior.\n   * @param date - Date to modify\n   */\n  private setToLastDayOfPreviousMonth(date: Date): void {\n    date.setUTCDate(0);\n  }\n}\n"]}

package/esm2022/widgets/implementations/datapoints-table/datapoints-table-view/virtual-scroll-listener.directive.mjs

@@ -0,0 +1,75 @@
+import { Directive, ElementRef, EventEmitter, Input, NgZone, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to listen for scroll events on a virtual scroll container.
+ * Emits `scrolled` and `scrolledToTop` events.
+ *
+ * The directive listens for scroll events on a virtual scroll container.
+ * - When the container is scrolled by at least 50 pixels (or a custom threshold), the `scrolled` event is emitted.
+ * - When the container is scrolled to the top, the `scrolledToTop` event is emitted.
+ *
+ */
+export class VirtualScrollListenerDirective {
+    constructor(el, ngZone) {
+        this.el = el;
+        this.ngZone = ngZone;
+        /**
+         * Pixel threshold for emitting the scrolled event.
+         */
+        this.scrollThreshold = 50;
+        /**
+         * Event emitted when the virtual scroll container is scrolled by at least 50 pixels.
+         */
+        this.scrolled = new EventEmitter();
+        /**
+         * Event emitted when the virtual scroll container is scrolled to the top.
+         */
+        this.scrolledToTop = new EventEmitter();
+        this.lastScrollTop = 0;
+    }
+    ngAfterViewInit() {
+        this.virtualScrollContainer = this.el.nativeElement.querySelector('.cdk-virtual-scroll-viewport');
+        if (this.virtualScrollContainer) {
+            this.ngZone.runOutsideAngular(() => {
+                this.virtualScrollContainer.addEventListener('scroll', this.onScroll.bind(this));
+            });
+        }
+    }
+    ngOnDestroy() {
+        if (this.virtualScrollContainer) {
+            this.virtualScrollContainer.removeEventListener('scroll', this.onScroll.bind(this));
+        }
+    }
+    /**
+     * Handles the scroll event. Emits `scrolled` event if scrolled by at least `scrollThreshold` pixels
+     * and `scrolledToTop` event if scrolled to the top.
+     * @param event - The scroll event.
+     */
+    onScroll(event) {
+        const target = event.target;
+        const scrollTop = target.scrollTop;
+        if (Math.abs(scrollTop - this.lastScrollTop) > this.scrollThreshold) {
+            this.lastScrollTop = scrollTop;
+            this.ngZone.run(() => this.scrolled.emit());
+        }
+        if (scrollTop === 0) {
+            this.ngZone.run(() => this.scrolledToTop.emit());
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScrollListenerDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: VirtualScrollListenerDirective, isStandalone: true, selector: "[c8yVirtualScrollListener]", inputs: { scrollThreshold: "scrollThreshold" }, outputs: { scrolled: "scrolled", scrolledToTop: "scrolledToTop" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScrollListenerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[c8yVirtualScrollListener]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { scrollThreshold: [{
+                type: Input
+            }], scrolled: [{
+                type: Output
+            }], scrolledToTop: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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