@c8y/ngx-components 1021.13.3 → 1021.21.0

package/esm2022/datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/data-processing.service.mjs

@@ -0,0 +1,207 @@
+import { Inject, Injectable } from '@angular/core';
+import JSZip from 'jszip';
+import { FILE_COMPRESSION_TYPES_VALUES, MEASUREMENTS_PREVIEW_ITEMS_LIMIT, SERIES_DATA_MERGED_FILE_NAME } from '../../datapoints-export-selector.model';
+import { FILE_GENERATORS } from './datapoints-export-selector-file-exporter.component';
+import { UtilsService } from './utils.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./utils.service";
+export class DataProcessingService {
+    constructor(fileGenerators, utils) {
+        this.fileGenerators = fileGenerators;
+        this.utils = utils;
+        this.mergeMapping = {};
+        this.setGenerators(this.fileGenerators);
+        this.fileTypesConfigs = this.fileGenerators.reduce((acc, g) => {
+            acc[g.getType()] = {
+                extension: g.getFileExtension(),
+                mimeType: g.getMimeType(),
+                acceptType: g.getAcceptType()
+            };
+            return acc;
+        }, {});
+    }
+    setGenerators(fileGenerators) {
+        fileGenerators.forEach(g => {
+            this.mergeMapping[g.getType()] = g.generateMerged;
+        });
+    }
+    /**
+     * Transforms the data into a structured format for an export.
+     *
+     * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.
+     * @returns Provides a two-dimensional array of ExportData,
+     *          where each inner array contains ExportData entries representing the transformed measurements and metadata of each datapoint.
+     */
+    transformToExportFileStructure(dataToExport) {
+        const exportData = [];
+        for (const data of dataToExport) {
+            const rowsData = this.processDataToExport(data);
+            exportData.push(rowsData);
+        }
+        return exportData;
+    }
+    /**
+     * Transforms the input datapoints with values into a structured format for a preview.
+     *
+     * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.
+     * @returns Provides an array of up to 5 ExportData elements (no more is needed for a preview) or an empty array,
+     */
+    transformToExportFileStructureForPreview(dataToExport) {
+        const data = dataToExport.find(data => {
+            return data !== null && data.timeValueMap && data.unit;
+        });
+        if (!data) {
+            return [];
+        }
+        const exportData = this.processDataToExport(data);
+        return exportData.slice(0, MEASUREMENTS_PREVIEW_ITEMS_LIMIT);
+    }
+    /**
+     * Processes a single dataToExport and transforms it into an array of ExportData.
+     *
+     * Used further for creating series data based export and also for measurements and series data based preview.
+     * Series data provides min and max values for each timestamp.
+     *
+     * @param dataToExport - A processed measurement or series data combined with the respective properties of the datapoint to be precessed
+     * @returns An array of ExportData representing the processed datapoint,
+     *          that can be used as a row data in the exported files or for preview.
+     */
+    processDataToExport(dataToExport) {
+        const rowsData = [];
+        // When measurements or series data is not available, add an empty header row with only device_name, source and fragment_series.
+        // This data is needed later to be used to create the file name and merged file header string.
+        const responseDoesNotContainData = !dataToExport.timeValueMap?.size && !dataToExport.unit;
+        if (responseDoesNotContainData) {
+            rowsData.push({
+                time: null,
+                source: dataToExport.source,
+                device_name: dataToExport.deviceName,
+                fragment_series: `${dataToExport.valueFragmentType}.${dataToExport.valueFragmentSeries}`,
+                value: null,
+                value_min: null,
+                value_max: null,
+                unit: null
+            });
+            return rowsData;
+        }
+        for (const [time, value] of Object.entries(dataToExport.timeValueMap)) {
+            // Measurements data contains only one value as a number, series data contains object with min and max values.
+            const isMeasurementData = typeof value === 'number';
+            if (isMeasurementData) {
+                rowsData.push(this.createExportData(dataToExport, time, isMeasurementData, value));
+            }
+            else {
+                rowsData.push(this.createExportData(dataToExport, time, isMeasurementData, value.min, value.max));
+            }
+        }
+        return rowsData;
+    }
+    createExportData(dataToExport, time, isMeasurement, value, valueMax) {
+        const commonExportData = {
+            time: new Date(time).toISOString(),
+            source: dataToExport.source,
+            device_name: dataToExport.deviceName,
+            fragment_series: `${dataToExport.valueFragmentType}.${dataToExport.valueFragmentSeries}`,
+            unit: dataToExport.unit
+        };
+        return isMeasurement
+            ? { ...commonExportData, value }
+            : { ...commonExportData, value_min: value, value_max: valueMax };
+    }
+    /**
+     * Exports the given data to merged CSV or Excel files.
+     *
+     * @param exportData - An array containing ExportData objects that will be used as parts of the merged file.
+     * @param fileType - Indicates the type of the file to be exported.
+     * @param mergedExportDetails - An object containing the date range from which the export was created and aggregation type.
+     * @returns An objects containing file name and its respective content as Blob.
+     *
+     * Example of exported merged file structure:
+     * date from	date to
+     * 2024-04-15T12:14:00.000Z	2024-07-16T14:14:28+02:00
+     * time	                          G6Fit -> c8y_Acceleration.accelerationX [G]	G6Fit -> c8y_Acceleration.accelerationY [G]
+     * 2024-05-13T13:45:10.500+02:00	0.0109026359624273	                        0.789461628278069
+     *
+     * Example of exported file name format:
+     * 04dec231240-06dec232350.xlsx
+     */
+    async exportSeriesDataToMergedFiles(exportData, fileType, mergedExportDetails) {
+        const fileTypeConfig = this.fileTypesConfigs[fileType];
+        mergedExportDetails.dateFrom = new Date(mergedExportDetails.dateFrom).toISOString();
+        mergedExportDetails.dateTo = new Date(mergedExportDetails.dateTo).toISOString();
+        const mergedFileContent = this.mergeMapping[fileType](exportData, mergedExportDetails);
+        const mergedFileNameDateRange = this.utils.getFormattedDateRange(mergedExportDetails.dateFrom, mergedExportDetails.dateTo);
+        return {
+            fileName: `${mergedFileNameDateRange}.${fileTypeConfig.extension}`,
+            fileData: new Blob([await mergedFileContent], { type: fileTypeConfig.mimeType })
+        };
+    }
+    /**
+     * Zips all created files.
+     *
+     * @param files - An array of objects containing file names and their respective content as Blobs.
+     * @returns A Promise that resolves to a Blob representing the generated zip file.
+     */
+    async zipFiles(files) {
+        const zip = new JSZip();
+        files.forEach(file => {
+            zip.file(file.fileName, file.fileData);
+        });
+        return await this.generateZipBlob(zip, FILE_COMPRESSION_TYPES_VALUES.deflate, 9);
+    }
+    /**
+     * Exports the given data to CSV or Excel files.
+     *
+     * @param params - An object containing all the necessary parameters for the export and zip process.
+     * @returns A Promise that resolves to a Blob representing the exported file.
+     */
+    async exportSeriesData(params) {
+        const { flattenedAndSortedExportData, fileType, mergedExportDetails } = params;
+        const exportedMergedFile = await this.exportSeriesDataToMergedFiles(flattenedAndSortedExportData, fileType, mergedExportDetails);
+        const blob = new Blob([exportedMergedFile.fileData], { type: fileType });
+        Object.defineProperty(blob, SERIES_DATA_MERGED_FILE_NAME, {
+            value: exportedMergedFile.fileName,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+        return blob;
+    }
+    createFileName(source, fragmentSeries, fileExtension) {
+        return `${source}_${fragmentSeries}.${fileExtension}`;
+    }
+    /**
+     * Generates a zip blob using the provided zip object.
+     *
+     * @param zip - The zip object used for generating the blob.
+     * @param compressionType - The compression type for the zip file. 'STORE' is no compression, 'DEFLATE' is compression.
+     * @param compressionLevel - The compression level for the zip file.
+     *                           Level 1 is quickest, 9 is best compressed.
+     * @returns A Promise that resolves to a Blob containing the generated zip file.
+     */
+    async generateZipBlob(zip, compressionType = FILE_COMPRESSION_TYPES_VALUES.store, compressionLevel = 1) {
+        const blob = 'blob';
+        if (compressionType === FILE_COMPRESSION_TYPES_VALUES.store) {
+            return await zip.generateAsync({ type: blob });
+        }
+        return await zip.generateAsync({
+            type: blob,
+            compression: compressionType,
+            compressionOptions: {
+                level: compressionLevel
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataProcessingService, deps: [{ token: FILE_GENERATORS }, { token: i1.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataProcessingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DataProcessingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FILE_GENERATORS]
+                }] }, { type: i1.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-processing.service.js","sourceRoot":"","sources":["../../../../../datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/data-processing.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport JSZip from 'jszip';\nimport {\n  DataToExport,\n  ExportData,\n  ExportedFile,\n  FILE_COMPRESSION_TYPES_VALUES,\n  FileCompressionTypes,\n  FileGenerator,\n  MEASUREMENTS_PREVIEW_ITEMS_LIMIT,\n  MergedExportDetails,\n  SERIES_DATA_MERGED_FILE_NAME,\n  SeriesExportParams\n} from '../../datapoints-export-selector.model';\nimport { FILE_GENERATORS } from './datapoints-export-selector-file-exporter.component';\nimport { UtilsService } from './utils.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DataProcessingService {\n  mergeMapping = {};\n  fileTypesConfigs: {\n    [key: string]: {\n      extension: string;\n      mimeType: string;\n      acceptType: string;\n    };\n  };\n\n  constructor(\n    @Inject(FILE_GENERATORS) private fileGenerators: FileGenerator[],\n    private utils: UtilsService\n  ) {\n    this.setGenerators(this.fileGenerators);\n\n    this.fileTypesConfigs = this.fileGenerators.reduce((acc, g) => {\n      acc[g.getType()] = {\n        extension: g.getFileExtension(),\n        mimeType: g.getMimeType(),\n        acceptType: g.getAcceptType()\n      };\n      return acc;\n    }, {});\n  }\n\n  setGenerators(fileGenerators: FileGenerator[]) {\n    fileGenerators.forEach(g => {\n      this.mergeMapping[g.getType()] = g.generateMerged;\n    });\n  }\n\n  /**\n   * Transforms the data into a structured format for an export.\n   *\n   * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.\n   * @returns Provides a two-dimensional array of ExportData,\n   *          where each inner array contains ExportData entries representing the transformed measurements and metadata of each datapoint.\n   */\n  transformToExportFileStructure(dataToExport: DataToExport[]): ExportData[][] {\n    const exportData: ExportData[][] = [];\n\n    for (const data of dataToExport) {\n      const rowsData: ExportData[] = this.processDataToExport(data);\n      exportData.push(rowsData);\n    }\n    return exportData;\n  }\n\n  /**\n   * Transforms the input datapoints with values into a structured format for a preview.\n   *\n   * @param dataToExport - An array of processed measurement data combined with the respective properties of the datapoint.\n   * @returns Provides an array of up to 5 ExportData elements (no more is needed for a preview) or an empty array,\n   */\n  transformToExportFileStructureForPreview(dataToExport: DataToExport[]): ExportData[] {\n    const data = dataToExport.find(data => {\n      return data !== null && data.timeValueMap && data.unit;\n    });\n\n    if (!data) {\n      return [];\n    }\n\n    const exportData = this.processDataToExport(data);\n\n    return exportData.slice(0, MEASUREMENTS_PREVIEW_ITEMS_LIMIT);\n  }\n\n  /**\n   * Processes a single dataToExport and transforms it into an array of ExportData.\n   *\n   * Used further for creating series data based export and also for measurements and series data based preview.\n   * Series data provides min and max values for each timestamp.\n   *\n   * @param dataToExport - A processed measurement or series data combined with the respective properties of the datapoint to be precessed\n   * @returns An array of ExportData representing the processed datapoint,\n   *          that can be used as a row data in the exported files or for preview.\n   */\n  processDataToExport(dataToExport: DataToExport): ExportData[] {\n    const rowsData: ExportData[] = [];\n\n    // When measurements or series data is not available, add an empty header row with only device_name, source and fragment_series.\n    // This data is needed later to be used to create the file name and merged file header string.\n    const responseDoesNotContainData = !dataToExport.timeValueMap?.size && !dataToExport.unit;\n    if (responseDoesNotContainData) {\n      rowsData.push({\n        time: null,\n        source: dataToExport.source,\n        device_name: dataToExport.deviceName,\n        fragment_series: `${dataToExport.valueFragmentType}.${dataToExport.valueFragmentSeries}`,\n        value: null,\n        value_min: null,\n        value_max: null,\n        unit: null\n      });\n      return rowsData;\n    }\n\n    for (const [time, value] of Object.entries(dataToExport.timeValueMap)) {\n      // Measurements data contains only one value as a number, series data contains object with min and max values.\n      const isMeasurementData = typeof value === 'number';\n      if (isMeasurementData) {\n        rowsData.push(this.createExportData(dataToExport, time, isMeasurementData, value));\n      } else {\n        rowsData.push(\n          this.createExportData(dataToExport, time, isMeasurementData, value.min, value.max)\n        );\n      }\n    }\n    return rowsData;\n  }\n\n  createExportData(\n    dataToExport: DataToExport,\n    time: string,\n    isMeasurement: boolean,\n    value: number,\n    valueMax?: number\n  ): ExportData {\n    const commonExportData = {\n      time: new Date(time).toISOString(),\n      source: dataToExport.source,\n      device_name: dataToExport.deviceName,\n      fragment_series: `${dataToExport.valueFragmentType}.${dataToExport.valueFragmentSeries}`,\n      unit: dataToExport.unit\n    };\n\n    return isMeasurement\n      ? { ...commonExportData, value }\n      : { ...commonExportData, value_min: value, value_max: valueMax };\n  }\n\n  /**\n   * Exports the given data to merged CSV or Excel files.\n   *\n   * @param exportData - An array containing ExportData objects that will be used as parts of the merged file.\n   * @param fileType - Indicates the type of the file to be exported.\n   * @param mergedExportDetails - An object containing the date range from which the export was created and aggregation type.\n   * @returns An objects containing file name and its respective content as Blob.\n   *\n   * Example of exported merged file structure:\n   * date from\tdate to\n   * 2024-04-15T12:14:00.000Z\t2024-07-16T14:14:28+02:00\n   * time\t                          G6Fit -> c8y_Acceleration.accelerationX [G]\tG6Fit -> c8y_Acceleration.accelerationY [G]\n   * 2024-05-13T13:45:10.500+02:00\t0.0109026359624273\t                        0.789461628278069\n   *\n   * Example of exported file name format:\n   * 04dec231240-06dec232350.xlsx\n   */\n  async exportSeriesDataToMergedFiles(\n    exportData: ExportData[],\n    fileType: string,\n    mergedExportDetails: MergedExportDetails\n  ): Promise<ExportedFile> {\n    const fileTypeConfig = this.fileTypesConfigs[fileType];\n\n    mergedExportDetails.dateFrom = new Date(mergedExportDetails.dateFrom).toISOString();\n    mergedExportDetails.dateTo = new Date(mergedExportDetails.dateTo).toISOString();\n\n    const mergedFileContent = this.mergeMapping[fileType](exportData, mergedExportDetails);\n\n    const mergedFileNameDateRange = this.utils.getFormattedDateRange(\n      mergedExportDetails.dateFrom,\n      mergedExportDetails.dateTo\n    );\n    return {\n      fileName: `${mergedFileNameDateRange}.${fileTypeConfig.extension}`,\n      fileData: new Blob([await mergedFileContent], { type: fileTypeConfig.mimeType })\n    };\n  }\n\n  /**\n   * Zips all created files.\n   *\n   * @param files - An array of objects containing file names and their respective content as Blobs.\n   * @returns A Promise that resolves to a Blob representing the generated zip file.\n   */\n  async zipFiles(files: ExportedFile[]): Promise<Blob> {\n    const zip = new JSZip();\n\n    files.forEach(file => {\n      zip.file(file.fileName, file.fileData);\n    });\n\n    return await this.generateZipBlob(zip, FILE_COMPRESSION_TYPES_VALUES.deflate, 9);\n  }\n\n  /**\n   * Exports the given data to CSV or Excel files.\n   *\n   * @param params - An object containing all the necessary parameters for the export and zip process.\n   * @returns A Promise that resolves to a Blob representing the exported file.\n   */\n  async exportSeriesData(params: SeriesExportParams): Promise<Blob> {\n    const { flattenedAndSortedExportData, fileType, mergedExportDetails } = params;\n    const exportedMergedFile: ExportedFile = await this.exportSeriesDataToMergedFiles(\n      flattenedAndSortedExportData,\n      fileType,\n      mergedExportDetails\n    );\n\n    const blob = new Blob([exportedMergedFile.fileData], { type: fileType });\n\n    Object.defineProperty(blob, SERIES_DATA_MERGED_FILE_NAME, {\n      value: exportedMergedFile.fileName,\n      writable: false,\n      enumerable: false,\n      configurable: true\n    });\n\n    return blob;\n  }\n\n  createFileName(source: string | number, fragmentSeries: string, fileExtension: string): string {\n    return `${source}_${fragmentSeries}.${fileExtension}`;\n  }\n\n  /**\n   * Generates a zip blob using the provided zip object.\n   *\n   * @param zip - The zip object used for generating the blob.\n   * @param compressionType - The compression type for the zip file. 'STORE' is no compression, 'DEFLATE' is compression.\n   * @param compressionLevel - The compression level for the zip file.\n   *                           Level 1 is quickest, 9 is best compressed.\n   * @returns A Promise that resolves to a Blob containing the generated zip file.\n   */\n  private async generateZipBlob(\n    zip: JSZip,\n    compressionType: FileCompressionTypes = FILE_COMPRESSION_TYPES_VALUES.store,\n    compressionLevel = 1\n  ): Promise<Blob> {\n    const blob = 'blob';\n\n    if (compressionType === FILE_COMPRESSION_TYPES_VALUES.store) {\n      return await zip.generateAsync({ type: blob });\n    }\n    return await zip.generateAsync({\n      type: blob,\n      compression: compressionType,\n      compressionOptions: {\n        level: compressionLevel\n      }\n    });\n  }\n}\n"]}