@c8y/ngx-components 1021.11.1 → 1021.21.0

package/esm2022/datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/datapoints-export-selector-file-exporter.component.mjs

@@ -0,0 +1,467 @@
+import { KeyValuePipe } from '@angular/common';
+import { Component, EventEmitter, Inject, InjectionToken, Input, Output } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { FormBuilder, FormControl, ReactiveFormsModule } from '@angular/forms';
+import { AGGREGATION_VALUES, CoreModule } from '@c8y/ngx-components';
+import saveAs from 'file-saver';
+import { debounceTime, merge, Subject, takeUntil } from 'rxjs';
+import { EXPORT_MODE_VALUES, SERIES_DATA_MERGED_FILE_NAME } from '../../datapoints-export-selector.model';
+import { DataFetchingService } from './data-fetching.service';
+import { DataProcessingService } from './data-processing.service';
+import { DatapointsExportSelectorFileExporterService } from './datapoints-export-selector-file-exporter.service';
+import { DataPointsExportSelectorPreviewComponent } from './datapoints-export-selector-preview/datapoints-export-selector-preview.component';
+import { DataPointsExportSelectorDataScopeComponent } from './datapoints-exports-selector-data-scope/datapoints-exports-selector-data-scope.component';
+import { DataPointsExportSelectorFileTypesComponent } from './datapoints-exports-selector-file-types/datapoints-exports-selector-file-types.component';
+import { DataPointsExportSelectorTimeRangeComponent } from './datapoints-exports-selector-time-range/datapoints-exports-selector-time-range.component';
+import { CSVGeneratorAdapter } from './generators/csv-generator';
+import { ExcelGeneratorAdapter } from './generators/excel-generator';
+import * as i0 from "@angular/core";
+import * as i1 from "./data-processing.service";
+import * as i2 from "./data-fetching.service";
+import * as i3 from "./datapoints-export-selector-file-exporter.service";
+import * as i4 from "@angular/forms";
+import * as i5 from "@c8y/ngx-components";
+import * as i6 from "@angular/common";
+export const FILE_GENERATORS = new InjectionToken('FILE_GENERATORS', {
+    providedIn: 'root',
+    factory: () => [ExcelGeneratorAdapter, CSVGeneratorAdapter]
+});
+export const dateRangeValidator = (control) => {
+    const dateFrom = control.get('dateFrom');
+    const dateTo = control.get('dateTo');
+    if (!dateFrom || !dateTo) {
+        return null;
+    }
+    const dateFromValue = dateFrom.value;
+    const dateToValue = dateTo.value;
+    if (dateFromValue && dateToValue) {
+        if (new Date(dateFromValue) > new Date(dateToValue)) {
+            dateFrom.setErrors({ dateAfterRangeMax: true });
+            dateTo.setErrors({ dateBeforeRangeMin: true });
+        }
+        else {
+            dateFrom.setErrors(null);
+            dateTo.setErrors(null);
+        }
+    }
+    return null;
+};
+export class DatapointsExportSelectorFileExporterComponent {
+    constructor(datapointsExportModalService, datapointsExportSelectorService, datapointsExportSelectorFileExporterService, formBuilder, generators) {
+        this.datapointsExportModalService = datapointsExportModalService;
+        this.datapointsExportSelectorService = datapointsExportSelectorService;
+        this.datapointsExportSelectorFileExporterService = datapointsExportSelectorFileExporterService;
+        this.formBuilder = formBuilder;
+        this.generators = generators;
+        this.onDownloadButtonStateChange = new EventEmitter();
+        /**
+         * Represents aggregation selector options that are disabled.
+         * This state is determined based on the current date range.
+         */
+        this.disabledAggregationOptions = {};
+        /**
+         * Contains all datapoints that number of records exceeds a threshold, where data for these datapoints will be processed by the backend.
+         * Applies only to measurement API which can return processed CSV, Excel or XML data.
+         */
+        this.datapointsExceedingBrowserDownloadLimit = [];
+        /**
+         * Indicates whether any of DataToExport objects timeValueMap property is not undefined (series data)
+         * or dataPointToExport is not undefined at all (measurement data).
+         */
+        this.hasFetchedDataAnyValuesToExport = false;
+        this.hasPermissionToReadAnyMeasurements = false;
+        this.isPreviewLoading = true;
+        /**
+         * Indicates whether the full or compact type of export is selected.
+         * Full type of export is based on measurement API data.
+         * Compact type of export is based on series API data.
+         */
+        this.isFullTypeOfExport = false;
+        /**
+         * Indicates whether the aggregation value was changed programmatically.
+         * It prevents a case where fetching may be triggered twice when export type is changed.
+         * Both options alone can trigger fetching data.
+         */
+        this.isAggregationChangedProgrammatically = false;
+        /**
+         * Indicates whether any of the export file types (CSV, Excel) are checked.
+         */
+        this.isAnyOfExportFileTypeChecked = false;
+        this.dateFromSubject = new Subject();
+        this.dateToSubject = new Subject();
+        this.destroy$ = new Subject();
+        this.dynamicFilesTypeMetadata = {};
+        this.setFilesType(this.generators);
+        this.dateFromSubject
+            .pipe(debounceTime(300), takeUntilDestroyed())
+            .subscribe(async (updatedDate) => {
+            await this.updateDateAndFetchData('dateFrom', updatedDate);
+        });
+        this.dateToSubject
+            .pipe(debounceTime(300), takeUntilDestroyed())
+            .subscribe(async (updatedDate) => {
+            await this.updateDateAndFetchData('dateTo', updatedDate);
+        });
+    }
+    setFilesType(generators) {
+        generators.forEach(g => {
+            this.dynamicFilesTypeMetadata[g.getType()] = {
+                label: g.getLabel(),
+                icon: g.getIcon(),
+                title: g.getTitle(),
+                extension: g.getFileExtension(),
+                zipName: g.getZipName(),
+                type: g.getType()
+            };
+        });
+    }
+    async ngOnInit() {
+        const sourcesPermittedToRead = await this.datapointsExportSelectorService.getSourcesWithPermissionsToRead(this.exportConfig.datapointDetails);
+        if (sourcesPermittedToRead.length === 0) {
+            return;
+        }
+        if (sourcesPermittedToRead.length !== this.exportConfig.datapointDetails.length) {
+            this.exportConfig.datapointDetails = this.exportConfig.datapointDetails.filter(dataPoint => sourcesPermittedToRead.includes(String(dataPoint.source)));
+        }
+        this.hasPermissionToReadAnyMeasurements = true;
+        this.storeInitialChangeableConfig();
+        this.fileTypeSelectionState = this.getInitialSelection(this.dynamicFilesTypeMetadata, [0]);
+        this.formGroup = this.createForm();
+        this.dataToExport = await this.datapointsExportSelectorService.fetchAndPrepareDataToExport(this.exportConfig, this.isFullTypeOfExport);
+        this.handleDateSelectorChanges();
+        this.determineShowingPreviewOrEmptyState();
+        this.handleExportModeChanges();
+        this.handleFileTypeSelectionChanges();
+        this.handleFormValidationChanges();
+        this.updateFileTypeControl();
+        this.updateDisabledAggregationOptionsState();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.loadInitialChangeableConfig();
+    }
+    async exportAndDownload() {
+        const fileExports = Object.entries(this.dynamicFilesTypeMetadata).map(([_, value]) => ({
+            fileType: value.type,
+            zipName: value.zipName
+        }));
+        const selectedFileExports = this.getOnlySelectedFileExports(fileExports);
+        await Promise.all(selectedFileExports.map(async ({ fileType, zipName }) => {
+            const blob = await this.exportFile(fileType);
+            await this.downloadFile(blob, fileType, zipName);
+        }));
+        this.datapointsExportSelectorFileExporterService.cleanupCachedData();
+    }
+    getOnlySelectedFileExports(fileExports) {
+        return fileExports.filter(f => this.fileTypeSelectionState[f.fileType] === true);
+    }
+    async exportFile(fileType) {
+        return this.isFullTypeOfExport
+            ? await this.exportMeasurementFile(fileType)
+            : await this.exportSeriesFile(fileType);
+    }
+    async downloadFile(blob, fileType, measurementsZipFileName) {
+        this.datapointsExceedingBrowserDownloadLimit =
+            this.datapointsExceedingBrowserDownloadLimit.filter(datapoint => !this.dataPointsExceedingOneMillionLimit.includes(datapoint));
+        const shouldShowAlert = this.datapointsExceedingBrowserDownloadLimit.length > 0;
+        // Handles a case where all files are sent by email.
+        if (!blob && shouldShowAlert) {
+            this.datapointsExportSelectorService.showSendViaEmailInfoAlert(fileType, this.datapointsExceedingBrowserDownloadLimit);
+            return;
+        }
+        if (blob) {
+            // Handles the case where some of the files are sent by email.
+            if (shouldShowAlert) {
+                this.datapointsExportSelectorService.showSendViaEmailInfoAlert(fileType, this.datapointsExceedingBrowserDownloadLimit);
+            }
+            this.isFullTypeOfExport
+                ? saveAs(blob, measurementsZipFileName)
+                : saveAs(blob, blob[SERIES_DATA_MERGED_FILE_NAME]);
+        }
+    }
+    /**
+     * Exports a measurement file of the specified type.
+     *
+     * Measurements API does provide a way to fetch a preprocessed CSV/Excel file.
+     *
+     * At this point a backed file needs to be fetched.
+     * Measurement data used for a preview contains just 5 first records
+     * and it's not fetched with CSV/Excel headers.
+     *
+     * @param fileType - The type of file to export.
+     * @returns A Promise that resolves to a Blob representing the exported file or null when no data to export or it's sent via email.
+     */
+    async exportMeasurementFile(fileType) {
+        const { acceptType, extension } = this.datapointsExportModalService.fileTypesConfigs[fileType];
+        const updatedExportConfig = this.excludeDatapointsThatExceedsApiLimit(this.exportConfig);
+        const dataToExport = await this.datapointsExportSelectorService.fetchMeasurementDataFilesAndPairWithSourceDetails(acceptType, updatedExportConfig);
+        const isAllUndefined = dataToExport.every(data => data === undefined);
+        if (isAllUndefined) {
+            return null;
+        }
+        return this.datapointsExportSelectorFileExporterService.getMeasurementExportedDataBlob(extension, dataToExport);
+    }
+    excludeDatapointsThatExceedsApiLimit(exportConfig) {
+        const skippedDatapointsSource = this.dataPointsExceedingOneMillionLimit.map(datapoint => datapoint.datapointDetail.source.toString());
+        const filteredDatapoints = exportConfig.datapointDetails.filter(datapoint => !skippedDatapointsSource.includes(String(datapoint.source)));
+        exportConfig.datapointDetails = filteredDatapoints;
+        return exportConfig;
+    }
+    /**
+     * Exports the series data to a file of the specified type.
+     *
+     * Series API does not provide a way to fetch a preprocessed CSV/Excel file.
+     *
+     * Series data used for exporting a file is already fetched for a preview
+     * and can be reused for exporting.
+     *
+     * @param fileType - The type of file to export (e.g., CSV, Excel).
+     * @returns A Promise that resolves to a Blob representing the exported file.
+     */
+    async exportSeriesFile(fileType) {
+        const mergedExportDetails = {
+            aggregation: this.exportConfig.aggregation,
+            dateFrom: this.exportConfig.dateFrom,
+            dateTo: this.exportConfig.dateTo
+        };
+        return this.datapointsExportSelectorFileExporterService.getSeriesExportedDataBlob(fileType, this.dataToExport, mergedExportDetails);
+    }
+    async onAggregationChange(aggregation) {
+        this.exportConfig.aggregation = aggregation;
+        if (!this.isAggregationChangedProgrammatically) {
+            await this.updateExportConfigAndFetchData();
+            this.updateDownloadButtonState();
+        }
+    }
+    onDateFromChange(updatedDate) {
+        this.dateFromSubject.next(updatedDate);
+    }
+    onDateToChange(updatedDate) {
+        this.dateToSubject.next(updatedDate);
+    }
+    async updateDateAndFetchData(dateType, updatedDate) {
+        this.exportConfig[dateType] = updatedDate;
+        await this.updateExportConfigAndFetchData();
+        if (this.isFullTypeOfExport) {
+            await this.determineIfMeasurementResponseWillBeProcessedByBackend();
+        }
+        else {
+            this.updateDownloadButtonState();
+        }
+    }
+    async onExportTypeChange(exportType) {
+        if (exportType === EXPORT_MODE_VALUES.full) {
+            this.isAggregationChangedProgrammatically = true;
+            this.formGroup.controls.aggregation.setValue(AGGREGATION_VALUES.none);
+            this.isAggregationChangedProgrammatically = false;
+            this.isFullTypeOfExport = true;
+            await this.updateExportConfigAndFetchData();
+            await this.determineIfMeasurementResponseWillBeProcessedByBackend();
+            return;
+        }
+        this.resetFullExportRelatedProperties();
+        this.isFullTypeOfExport = false;
+        await this.updateExportConfigAndFetchData();
+        this.updateDisabledAggregationOptionsState();
+        this.updateDownloadButtonState();
+    }
+    updateDisabledAggregationOptionsState() {
+        this.disabledAggregationOptions =
+            this.datapointsExportSelectorFileExporterService.updateDisabledStateOfAggregationOptionEntries(this.formGroup.controls.dateFrom.value, this.formGroup.controls.dateTo.value, this.disabledAggregationOptions);
+    }
+    createForm() {
+        return this.formBuilder.group({
+            dateFrom: new FormControl(this.exportConfig.dateFrom),
+            dateTo: new FormControl(this.exportConfig.dateTo),
+            aggregation: new FormControl(this.exportConfig.aggregation ? this.exportConfig.aggregation : AGGREGATION_VALUES.none),
+            exportMode: new FormControl(EXPORT_MODE_VALUES.compact),
+            fileTypes: this.formBuilder.group(this.generators.reduce((a, c) => {
+                a[c.getType()] = false;
+                return a;
+            }, {}))
+        }, {
+            validators: [dateRangeValidator]
+        });
+    }
+    preparePreview() {
+        this.isPreviewLoading = true;
+        this.previewTableData =
+            this.datapointsExportModalService.transformToExportFileStructureForPreview(this.dataToExport);
+        this.isPreviewLoading = false;
+    }
+    handleDateSelectorChanges() {
+        const aggregationControl = this.formGroup.controls.aggregation;
+        const dateFromSelector = this.formGroup.controls.dateFrom;
+        const dateToSelector = this.formGroup.controls.dateTo;
+        const updateAggregationOptions = () => {
+            if (!this.isFullTypeOfExport) {
+                this.updateDisabledAggregationOptionsState();
+                const firstAvailableAggregationValue = this.datapointsExportSelectorFileExporterService.setToFirstAvailableAggregationOptionIfCurrentIsDisabled(aggregationControl.value, this.disabledAggregationOptions);
+                if (firstAvailableAggregationValue) {
+                    aggregationControl.setValue(firstAvailableAggregationValue);
+                }
+            }
+        };
+        merge(dateFromSelector.valueChanges, dateToSelector.valueChanges)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(updateAggregationOptions);
+    }
+    handleExportModeChanges() {
+        const aggregationControl = this.formGroup.controls.aggregation;
+        this.formGroup.controls.exportMode.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(exportModeValue => {
+            if (exportModeValue.toString() === EXPORT_MODE_VALUES.full) {
+                aggregationControl.disable();
+            }
+            else {
+                aggregationControl.enable();
+            }
+        });
+    }
+    handleFileTypeSelectionChanges() {
+        this.formGroup.controls.fileTypes.valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(fileTypesSelectionState => {
+            this.updateFileTypeSelectionState(fileTypesSelectionState);
+        });
+    }
+    updateFileTypeSelectionState(checkboxesState) {
+        this.isAnyOfExportFileTypeChecked = Object.values(checkboxesState).some(value => value === true);
+        this.fileTypeSelectionState = checkboxesState;
+        this.updateDownloadButtonState();
+    }
+    handleFormValidationChanges() {
+        this.formGroup.statusChanges.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.updateDownloadButtonState();
+        });
+    }
+    updateFileTypeControl() {
+        const fileTypesControl = this.formGroup.controls.fileTypes;
+        if (fileTypesControl) {
+            const currentValue = fileTypesControl.value || {};
+            const updatedValue = { ...currentValue };
+            Object.entries(this.fileTypeSelectionState).forEach(([fileType, isSelected]) => {
+                if (fileType in currentValue) {
+                    updatedValue[fileType] = isSelected;
+                }
+            });
+            fileTypesControl.patchValue(updatedValue);
+        }
+    }
+    determineShowingPreviewOrEmptyState() {
+        const hasDataToShow = this.dataToExport.some(dataToExportItem => this.isFullTypeOfExport
+            ? !!dataToExportItem
+            : dataToExportItem.timeValueMap && Object.keys(dataToExportItem.timeValueMap).length > 0);
+        this.hasFetchedDataAnyValuesToExport = hasDataToShow;
+        if (hasDataToShow) {
+            this.preparePreview();
+        }
+        else {
+            this.isPreviewLoading = false;
+        }
+    }
+    async determineIfMeasurementResponseWillBeProcessedByBackend() {
+        this.isPreviewLoading = true;
+        this.datapointsExceedingBrowserDownloadLimit =
+            await this.datapointsExportSelectorService.getDatapointsExceedingLimit(this.exportConfig);
+        const { browserDownloadableCount, emailDeliverableCount, nonRetrievableCount } = this.calculateDatapointCounts();
+        this.hasNoExportableData =
+            browserDownloadableCount === 0 && emailDeliverableCount === 0 && nonRetrievableCount > 0;
+        if (this.datapointsExceedingBrowserDownloadLimit.length > 0 && !this.hasNoExportableData) {
+            this.limitExceededMessage = this.datapointsExportSelectorService.getLimitExceededMessage(this.hasNoExportableData, emailDeliverableCount, browserDownloadableCount, nonRetrievableCount, this.exportConfig.datapointDetails.length);
+        }
+        if (this.datapointsExceedingBrowserDownloadLimit.length > 0 && this.hasNoExportableData) {
+            this.limitExceededMessage = this.datapointsExportSelectorService.getLimitExceededMessage(this.hasNoExportableData);
+        }
+        this.updateDownloadButtonState();
+        this.isPreviewLoading = false;
+    }
+    calculateDatapointCounts() {
+        const RECORD_API_LIMIT = 1_000_000;
+        this.dataPointsExceedingOneMillionLimit = this.datapointsExceedingBrowserDownloadLimit.filter(datapointsExceedingBrowserDownloadLimit => datapointsExceedingBrowserDownloadLimit.totalElements > RECORD_API_LIMIT);
+        const nonRetrievableCount = this.dataPointsExceedingOneMillionLimit.length;
+        const emailDeliverableCount = this.datapointsExceedingBrowserDownloadLimit.length - nonRetrievableCount;
+        const browserDownloadableCount = this.exportConfig.datapointDetails.length - emailDeliverableCount - nonRetrievableCount;
+        return {
+            browserDownloadableCount,
+            emailDeliverableCount,
+            nonRetrievableCount
+        };
+    }
+    storeInitialChangeableConfig() {
+        this.initialDateFrom = this.exportConfig.dateFrom;
+        this.initialDateTo = this.exportConfig.dateTo;
+        this.initialDatapointDetails = this.exportConfig.datapointDetails;
+        if (!this.isFullTypeOfExport) {
+            this.initialAggregation = this.exportConfig.aggregation;
+        }
+    }
+    loadInitialChangeableConfig() {
+        this.exportConfig.dateFrom = this.initialDateFrom;
+        this.exportConfig.dateTo = this.initialDateTo;
+        this.exportConfig.datapointDetails = this.initialDatapointDetails;
+        if (!this.isFullTypeOfExport) {
+            this.exportConfig.aggregation = this.initialAggregation;
+        }
+    }
+    async updateExportConfigAndFetchData() {
+        if (this.formGroup.invalid) {
+            return;
+        }
+        this.isPreviewLoading = true;
+        this.onDownloadButtonStateChange.emit(false);
+        this.dataToExport = await this.datapointsExportSelectorService.fetchAndPrepareDataToExport(this.exportConfig, this.isFullTypeOfExport);
+        this.determineShowingPreviewOrEmptyState();
+    }
+    updateDownloadButtonState() {
+        const canEnableDownloadButton = this.hasFetchedDataAnyValuesToExport &&
+            !this.formGroup.invalid &&
+            this.isAnyOfExportFileTypeChecked &&
+            !this.hasNoExportableData;
+        this.onDownloadButtonStateChange.emit(canEnableDownloadButton);
+    }
+    resetFullExportRelatedProperties() {
+        this.hasNoExportableData = false;
+        this.datapointsExceedingBrowserDownloadLimit = [];
+    }
+    getInitialSelection(fileType, selectByDefault) {
+        const keys = Object.keys(fileType);
+        if (keys.length === 0) {
+            return {};
+        }
+        const initialSelection = keys.reduce((acc, key) => {
+            acc[key] = false;
+            return acc;
+        }, {});
+        selectByDefault.forEach(index => {
+            if (index >= 0 && index < keys.length) {
+                initialSelection[keys[index]] = true;
+            }
+        });
+        return initialSelection;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterComponent, deps: [{ token: i1.DataProcessingService }, { token: i2.DataFetchingService }, { token: i3.DatapointsExportSelectorFileExporterService }, { token: i4.FormBuilder }, { token: FILE_GENERATORS }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: DatapointsExportSelectorFileExporterComponent, isStandalone: true, selector: "c8y-datapoints-export-selector-file-exporter", inputs: { exportConfig: "exportConfig" }, outputs: { onDownloadButtonStateChange: "onDownloadButtonStateChange" }, ngImport: i0, template: "<div class=\"p-b-16\">\n  <ng-container *ngIf=\"hasPermissionToReadAnyMeasurements; else hasNoRoleToReadAnyMeasurements\">\n    <div class=\"p-16 text-center separator-bottom sticky-top bg-component\">\n      <p class=\"text-medium text-16\">\n        {{ 'Configure export' | translate }}\n      </p>\n    </div>\n    <div\n      class=\"p-t-24 p-r-16 p-l-16 gap-8 p-b-16 flex-wrap\"\n      [ngClass]=\"{ 'separator-bottom': isFullTypeOfExport }\"\n    >\n      <div class=\"row\">\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-time-range\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [formGroup]=\"formGroup\"\n            (onDateFromChange)=\"onDateFromChange($event)\"\n            (onDateToChange)=\"onDateToChange($event)\"\n          ></c8y-datapoints-export-selector-time-range>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-data-scope\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [disabledAggregationOptions]=\"disabledAggregationOptions\"\n            [formGroup]=\"formGroup\"\n            (onAggregationChange)=\"onAggregationChange($event)\"\n            (onExportTypeChange)=\"onExportTypeChange($event)\"\n          ></c8y-datapoints-export-selector-data-scope>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-file-types\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [dynamicFilesTypeMetadata]=\"dynamicFilesTypeMetadata\"\n            [formGroup]=\"formGroup\"\n          ></c8y-datapoints-export-selector-file-types>\n        </div>\n      </div>\n    </div>\n    <ng-container\n      *ngIf=\"!isFullTypeOfExport && !hasFetchedDataAnyValuesToExport && !isPreviewLoading\"\n    >\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          class=\"alert alert-warning center-block\"\n          role=\"alert\"\n          data-cy=\"file-exporter--no-data-available\"\n          translate\n        >\n          No data available.\n        </div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"datapointsExceedingBrowserDownloadLimit.length > 0\">\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          [class]=\"\n            hasNoExportableData\n              ? 'alert alert-warning center-block'\n              : 'alert alert-info center-block'\n          \"\n          role=\"alert\"\n          [innerHTML]=\"limitExceededMessage\"\n        ></div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"isFullTypeOfExport\">\n      <c8y-datapoints-export-selector-preview\n        *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n        [hasFetchedDataAnyValuesToExport]=\"hasFetchedDataAnyValuesToExport\"\n        [isPreviewLoading]=\"isPreviewLoading\"\n        [previewTableData]=\"previewTableData\"\n      ></c8y-datapoints-export-selector-preview>\n    </ng-container>\n  </ng-container>\n  <ng-template #hasNoRoleToReadAnyMeasurements>\n    <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 d-flex\">\n      <div\n        class=\"alert alert-info center-block\"\n        role=\"alert\"\n        translate\n      >\n        <p>To export data, you must meet at least one of these criteria:</p>\n        <ul>\n          <li>\n            Have\n            <b>READ permission for \"Measurements\" permission type</b>\n            (either as a global role or for the specific source)\n          </li>\n          <li>\n            Be the\n            <b>owner of the source</b>\n            you want to export data from\n          </li>\n        </ul>\n        <p>Don't meet these requirements? Contact your system administrator for assistance.</p>\n      </div>\n    </div>\n  </ng-template>\n</div>\n", dependencies: [{ kind: "ngmodule", type: CoreModule }, { kind: "pipe", type: i5.C8yTranslatePipe, name: "translate" }, { kind: "directive", type: i5.C8yTranslateDirective, selector: "[translate],[ngx-translate]" }, { kind: "directive", type: i6.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: DataPointsExportSelectorDataScopeComponent, selector: "c8y-datapoints-export-selector-data-scope", inputs: ["disabledAggregationOptions", "formGroup"], outputs: ["onAggregationChange", "onExportTypeChange"] }, { kind: "component", type: DataPointsExportSelectorFileTypesComponent, selector: "c8y-datapoints-export-selector-file-types", inputs: ["dynamicFilesTypeMetadata", "formGroup"] }, { kind: "component", type: DataPointsExportSelectorPreviewComponent, selector: "c8y-datapoints-export-selector-preview", inputs: ["hasFetchedDataAnyValuesToExport", "isPreviewLoading", "previewTableData"] }, { kind: "component", type: DataPointsExportSelectorTimeRangeComponent, selector: "c8y-datapoints-export-selector-time-range", inputs: ["formGroup"], outputs: ["onDateFromChange", "onDateToChange"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: DatapointsExportSelectorFileExporterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c8y-datapoints-export-selector-file-exporter', standalone: true, imports: [
+                        CoreModule,
+                        DataPointsExportSelectorDataScopeComponent,
+                        DataPointsExportSelectorFileTypesComponent,
+                        DataPointsExportSelectorPreviewComponent,
+                        DataPointsExportSelectorTimeRangeComponent,
+                        KeyValuePipe,
+                        ReactiveFormsModule
+                    ], template: "<div class=\"p-b-16\">\n  <ng-container *ngIf=\"hasPermissionToReadAnyMeasurements; else hasNoRoleToReadAnyMeasurements\">\n    <div class=\"p-16 text-center separator-bottom sticky-top bg-component\">\n      <p class=\"text-medium text-16\">\n        {{ 'Configure export' | translate }}\n      </p>\n    </div>\n    <div\n      class=\"p-t-24 p-r-16 p-l-16 gap-8 p-b-16 flex-wrap\"\n      [ngClass]=\"{ 'separator-bottom': isFullTypeOfExport }\"\n    >\n      <div class=\"row\">\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-time-range\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [formGroup]=\"formGroup\"\n            (onDateFromChange)=\"onDateFromChange($event)\"\n            (onDateToChange)=\"onDateToChange($event)\"\n          ></c8y-datapoints-export-selector-time-range>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-data-scope\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [disabledAggregationOptions]=\"disabledAggregationOptions\"\n            [formGroup]=\"formGroup\"\n            (onAggregationChange)=\"onAggregationChange($event)\"\n            (onExportTypeChange)=\"onExportTypeChange($event)\"\n          ></c8y-datapoints-export-selector-data-scope>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-file-types\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [dynamicFilesTypeMetadata]=\"dynamicFilesTypeMetadata\"\n            [formGroup]=\"formGroup\"\n          ></c8y-datapoints-export-selector-file-types>\n        </div>\n      </div>\n    </div>\n    <ng-container\n      *ngIf=\"!isFullTypeOfExport && !hasFetchedDataAnyValuesToExport && !isPreviewLoading\"\n    >\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          class=\"alert alert-warning center-block\"\n          role=\"alert\"\n          data-cy=\"file-exporter--no-data-available\"\n          translate\n        >\n          No data available.\n        </div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"datapointsExceedingBrowserDownloadLimit.length > 0\">\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          [class]=\"\n            hasNoExportableData\n              ? 'alert alert-warning center-block'\n              : 'alert alert-info center-block'\n          \"\n          role=\"alert\"\n          [innerHTML]=\"limitExceededMessage\"\n        ></div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"isFullTypeOfExport\">\n      <c8y-datapoints-export-selector-preview\n        *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n        [hasFetchedDataAnyValuesToExport]=\"hasFetchedDataAnyValuesToExport\"\n        [isPreviewLoading]=\"isPreviewLoading\"\n        [previewTableData]=\"previewTableData\"\n      ></c8y-datapoints-export-selector-preview>\n    </ng-container>\n  </ng-container>\n  <ng-template #hasNoRoleToReadAnyMeasurements>\n    <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 d-flex\">\n      <div\n        class=\"alert alert-info center-block\"\n        role=\"alert\"\n        translate\n      >\n        <p>To export data, you must meet at least one of these criteria:</p>\n        <ul>\n          <li>\n            Have\n            <b>READ permission for \"Measurements\" permission type</b>\n            (either as a global role or for the specific source)\n          </li>\n          <li>\n            Be the\n            <b>owner of the source</b>\n            you want to export data from\n          </li>\n        </ul>\n        <p>Don't meet these requirements? Contact your system administrator for assistance.</p>\n      </div>\n    </div>\n  </ng-template>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i1.DataProcessingService }, { type: i2.DataFetchingService }, { type: i3.DatapointsExportSelectorFileExporterService }, { type: i4.FormBuilder }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FILE_GENERATORS]
+                }] }], propDecorators: { exportConfig: [{
+                type: Input
+            }], onDownloadButtonStateChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datapoints-export-selector-file-exporter.component.js","sourceRoot":"","sources":["../../../../../datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/datapoints-export-selector-file-exporter.component.ts","../../../../../datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/datapoints-export-selector-file-exporter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { KeyValuePipe } from '@angular/common';\nimport {\n  Component,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport {\n  AbstractControl,\n  FormBuilder,\n  FormControl,\n  ReactiveFormsModule,\n  ValidationErrors,\n  ValidatorFn\n} from '@angular/forms';\nimport {\n  AGGREGATION_VALUES,\n  AggregationOption,\n  AggregationOptionStatus,\n  CoreModule\n} from '@c8y/ngx-components';\nimport saveAs from 'file-saver';\nimport { debounceTime, merge, Subject, takeUntil } from 'rxjs';\nimport {\n  DatapointCounts,\n  DatapointDetails,\n  DatapointsExceedingLimit,\n  DataToExport,\n  DataToExportWithBackendCreatedFile,\n  EXPORT_MODE_VALUES,\n  ExportConfig,\n  ExportData,\n  FileExportConfig,\n  FileGenerator,\n  FileTypeMetadata,\n  MergedExportDetails,\n  SERIES_DATA_MERGED_FILE_NAME\n} from '../../datapoints-export-selector.model';\nimport { DataFetchingService } from './data-fetching.service';\nimport { DataProcessingService } from './data-processing.service';\nimport { DatapointsExportSelectorFileExporterService } from './datapoints-export-selector-file-exporter.service';\nimport { DataPointsExportSelectorPreviewComponent } from './datapoints-export-selector-preview/datapoints-export-selector-preview.component';\nimport { DataPointsExportSelectorDataScopeComponent } from './datapoints-exports-selector-data-scope/datapoints-exports-selector-data-scope.component';\nimport { DataPointsExportSelectorFileTypesComponent } from './datapoints-exports-selector-file-types/datapoints-exports-selector-file-types.component';\nimport { DataPointsExportSelectorTimeRangeComponent } from './datapoints-exports-selector-time-range/datapoints-exports-selector-time-range.component';\nimport { CSVGeneratorAdapter } from './generators/csv-generator';\nimport { ExcelGeneratorAdapter } from './generators/excel-generator';\n\nexport const FILE_GENERATORS = new InjectionToken<FileGenerator[]>('FILE_GENERATORS', {\n  providedIn: 'root',\n  factory: () => [ExcelGeneratorAdapter, CSVGeneratorAdapter]\n});\n\nexport const dateRangeValidator: ValidatorFn = (\n  control: AbstractControl\n): ValidationErrors | null => {\n  const dateFrom = control.get('dateFrom');\n  const dateTo = control.get('dateTo');\n\n  if (!dateFrom || !dateTo) {\n    return null;\n  }\n\n  const dateFromValue = dateFrom.value;\n  const dateToValue = dateTo.value;\n  if (dateFromValue && dateToValue) {\n    if (new Date(dateFromValue) > new Date(dateToValue)) {\n      dateFrom.setErrors({ dateAfterRangeMax: true });\n      dateTo.setErrors({ dateBeforeRangeMin: true });\n    } else {\n      dateFrom.setErrors(null);\n      dateTo.setErrors(null);\n    }\n  }\n  return null;\n};\n\n@Component({\n  selector: 'c8y-datapoints-export-selector-file-exporter',\n  templateUrl: './datapoints-export-selector-file-exporter.component.html',\n  standalone: true,\n  imports: [\n    CoreModule,\n    DataPointsExportSelectorDataScopeComponent,\n    DataPointsExportSelectorFileTypesComponent,\n    DataPointsExportSelectorPreviewComponent,\n    DataPointsExportSelectorTimeRangeComponent,\n    KeyValuePipe,\n    ReactiveFormsModule\n  ]\n})\nexport class DatapointsExportSelectorFileExporterComponent implements OnInit, OnDestroy {\n  @Input() exportConfig: ExportConfig;\n  @Output() onDownloadButtonStateChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n  /**\n   * Represents aggregation selector options that are disabled.\n   * This state is determined based on the current date range.\n   */\n  disabledAggregationOptions: AggregationOptionStatus = {};\n\n  formGroup: ReturnType<DatapointsExportSelectorFileExporterComponent['createForm']>;\n\n  /**\n   * Contains all datapoints that number of records exceeds a threshold, where data for these datapoints will be processed by the backend.\n   * Applies only to measurement API which can return processed CSV, Excel or XML data.\n   */\n  datapointsExceedingBrowserDownloadLimit: DatapointsExceedingLimit[] = [];\n  /**\n   * Indicates whether any of DataToExport objects timeValueMap property is not undefined (series data)\n   * or dataPointToExport is not undefined at all (measurement data).\n   */\n\n  hasFetchedDataAnyValuesToExport = false;\n\n  /**\n   * Indicates if there is no exportable data because the date range of all selected datapoints exceeds 1,000,000 records.\n   */\n  hasNoExportableData: boolean;\n\n  hasPermissionToReadAnyMeasurements = false;\n\n  isPreviewLoading = true;\n  /**\n   * Indicates whether the full or compact type of export is selected.\n   * Full type of export is based on measurement API data.\n   * Compact type of export is based on series API data.\n   */\n  isFullTypeOfExport = false;\n\n  previewTableData: ExportData[];\n\n  limitExceededMessage: string;\n\n  /**\n   * Contains processed data that is prepared to be exported if series data was fetched\n   * or shown in the preview table in case of measurements data.\n   */\n  private dataToExport: DataToExport[];\n  /**\n   * Contains a list of datapoints that selected date range exceeds API limit of 1_000_000 records.\n   */\n  private dataPointsExceedingOneMillionLimit: DatapointsExceedingLimit[];\n  /**\n   * Represents the state of file type selection checkboxes.\n   */\n  private fileTypeSelectionState: { [key: string]: boolean };\n  /**\n   * Hold the initial state of the aggregation from the export config.\n   * Value will be loaded on component destroy.\n   */\n  private initialAggregation: AggregationOption;\n  /**\n   * Hold the initial state of the dateFrom from the export config.\n   * Value will be loaded on component destroy.\n   */\n  private initialDateFrom: string;\n  /**\n   * Hold the initial state of the dateTo from the export config.\n   * Value will be loaded on component destroy.\n   */\n  private initialDateTo: string;\n  /**\n   * Hold the initial state of the datapointDetails from the export config.\n   * Some logic may filter out datapoints in datapointDetails array, that exceeds 1_000_000 limit for measurements API,\n   * but full list is still needed when component is reopened.\n   * Value will be loaded on component destroy.\n   */\n  private initialDatapointDetails: DatapointDetails[];\n  /**\n   * Indicates whether the aggregation value was changed programmatically.\n   * It prevents a case where fetching may be triggered twice when export type is changed.\n   * Both options alone can trigger fetching data.\n   */\n  private isAggregationChangedProgrammatically = false;\n  /**\n   * Indicates whether any of the export file types (CSV, Excel) are checked.\n   */\n  private isAnyOfExportFileTypeChecked = false;\n\n  private dateFromSubject = new Subject<string>();\n  private dateToSubject = new Subject<string>();\n  private destroy$ = new Subject<void>();\n\n  dynamicFilesTypeMetadata: { [key: string]: FileTypeMetadata } = {};\n\n  constructor(\n    private datapointsExportModalService: DataProcessingService,\n    private datapointsExportSelectorService: DataFetchingService,\n    private datapointsExportSelectorFileExporterService: DatapointsExportSelectorFileExporterService,\n    private formBuilder: FormBuilder,\n    @Inject(FILE_GENERATORS) private generators: FileGenerator[]\n  ) {\n    this.setFilesType(this.generators);\n\n    this.dateFromSubject\n      .pipe(debounceTime(300), takeUntilDestroyed())\n      .subscribe(async (updatedDate: string) => {\n        await this.updateDateAndFetchData('dateFrom', updatedDate);\n      });\n\n    this.dateToSubject\n      .pipe(debounceTime(300), takeUntilDestroyed())\n      .subscribe(async (updatedDate: string) => {\n        await this.updateDateAndFetchData('dateTo', updatedDate);\n      });\n  }\n\n  setFilesType(generators: FileGenerator[]) {\n    generators.forEach(g => {\n      this.dynamicFilesTypeMetadata[g.getType()] = {\n        label: g.getLabel(),\n        icon: g.getIcon(),\n        title: g.getTitle(),\n        extension: g.getFileExtension(),\n        zipName: g.getZipName(),\n        type: g.getType()\n      };\n    });\n  }\n\n  async ngOnInit(): Promise<void> {\n    const sourcesPermittedToRead: string[] =\n      await this.datapointsExportSelectorService.getSourcesWithPermissionsToRead(\n        this.exportConfig.datapointDetails\n      );\n\n    if (sourcesPermittedToRead.length === 0) {\n      return;\n    }\n\n    if (sourcesPermittedToRead.length !== this.exportConfig.datapointDetails.length) {\n      this.exportConfig.datapointDetails = this.exportConfig.datapointDetails.filter(dataPoint =>\n        sourcesPermittedToRead.includes(String(dataPoint.source))\n      );\n    }\n\n    this.hasPermissionToReadAnyMeasurements = true;\n\n    this.storeInitialChangeableConfig();\n\n    this.fileTypeSelectionState = this.getInitialSelection(this.dynamicFilesTypeMetadata, [0]);\n\n    this.formGroup = this.createForm();\n    this.dataToExport = await this.datapointsExportSelectorService.fetchAndPrepareDataToExport(\n      this.exportConfig,\n      this.isFullTypeOfExport\n    );\n\n    this.handleDateSelectorChanges();\n    this.determineShowingPreviewOrEmptyState();\n    this.handleExportModeChanges();\n    this.handleFileTypeSelectionChanges();\n    this.handleFormValidationChanges();\n\n    this.updateFileTypeControl();\n\n    this.updateDisabledAggregationOptionsState();\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.loadInitialChangeableConfig();\n  }\n\n  async exportAndDownload(): Promise<void> {\n    const fileExports: FileExportConfig[] = Object.entries(this.dynamicFilesTypeMetadata).map(\n      ([_, value]) => ({\n        fileType: value.type as string,\n        zipName: value.zipName\n      })\n    );\n\n    const selectedFileExports = this.getOnlySelectedFileExports(fileExports);\n\n    await Promise.all(\n      selectedFileExports.map(async ({ fileType, zipName }) => {\n        const blob = await this.exportFile(fileType);\n        await this.downloadFile(blob, fileType, zipName);\n      })\n    );\n\n    this.datapointsExportSelectorFileExporterService.cleanupCachedData();\n  }\n\n  getOnlySelectedFileExports(fileExports: FileExportConfig[]): FileExportConfig[] {\n    return fileExports.filter(f => this.fileTypeSelectionState[f.fileType] === true);\n  }\n\n  async exportFile(fileType: string): Promise<Blob | null> {\n    return this.isFullTypeOfExport\n      ? await this.exportMeasurementFile(fileType)\n      : await this.exportSeriesFile(fileType);\n  }\n\n  async downloadFile(\n    blob: Blob | null,\n    fileType: string,\n    measurementsZipFileName: string\n  ): Promise<void> {\n    this.datapointsExceedingBrowserDownloadLimit =\n      this.datapointsExceedingBrowserDownloadLimit.filter(\n        datapoint => !this.dataPointsExceedingOneMillionLimit.includes(datapoint)\n      );\n\n    const shouldShowAlert = this.datapointsExceedingBrowserDownloadLimit.length > 0;\n\n    // Handles a case where all files are sent by email.\n    if (!blob && shouldShowAlert) {\n      this.datapointsExportSelectorService.showSendViaEmailInfoAlert(\n        fileType,\n        this.datapointsExceedingBrowserDownloadLimit\n      );\n      return;\n    }\n\n    if (blob) {\n      // Handles the case where some of the files are sent by email.\n      if (shouldShowAlert) {\n        this.datapointsExportSelectorService.showSendViaEmailInfoAlert(\n          fileType,\n          this.datapointsExceedingBrowserDownloadLimit\n        );\n      }\n\n      this.isFullTypeOfExport\n        ? saveAs(blob, measurementsZipFileName)\n        : saveAs(blob, blob[SERIES_DATA_MERGED_FILE_NAME]);\n    }\n  }\n\n  /**\n   * Exports a measurement file of the specified type.\n   *\n   * Measurements API does provide a way to fetch a preprocessed CSV/Excel file.\n   *\n   * At this point a backed file needs to be fetched.\n   * Measurement data used for a preview contains just 5 first records\n   * and it's not fetched with CSV/Excel headers.\n   *\n   * @param fileType - The type of file to export.\n   * @returns A Promise that resolves to a Blob representing the exported file or null when no data to export or it's sent via email.\n   */\n  async exportMeasurementFile(fileType: string): Promise<Blob> | null {\n    const { acceptType, extension } = this.datapointsExportModalService.fileTypesConfigs[fileType];\n\n    const updatedExportConfig: ExportConfig = this.excludeDatapointsThatExceedsApiLimit(\n      this.exportConfig\n    );\n\n    const dataToExport: DataToExportWithBackendCreatedFile[] =\n      await this.datapointsExportSelectorService.fetchMeasurementDataFilesAndPairWithSourceDetails(\n        acceptType,\n        updatedExportConfig\n      );\n\n    const isAllUndefined = dataToExport.every(data => data === undefined);\n    if (isAllUndefined) {\n      return null;\n    }\n\n    return this.datapointsExportSelectorFileExporterService.getMeasurementExportedDataBlob(\n      extension,\n      dataToExport\n    );\n  }\n\n  excludeDatapointsThatExceedsApiLimit(exportConfig: ExportConfig): ExportConfig {\n    const skippedDatapointsSource: string[] = this.dataPointsExceedingOneMillionLimit.map(\n      datapoint => datapoint.datapointDetail.source.toString()\n    );\n\n    const filteredDatapoints: DatapointDetails[] = exportConfig.datapointDetails.filter(\n      datapoint => !skippedDatapointsSource.includes(String(datapoint.source))\n    );\n\n    exportConfig.datapointDetails = filteredDatapoints;\n    return exportConfig;\n  }\n\n  /**\n   * Exports the series data to a file of the specified type.\n   *\n   * Series API does not provide a way to fetch a preprocessed CSV/Excel file.\n   *\n   * Series data used for exporting a file is already fetched for a preview\n   * and can be reused for exporting.\n   *\n   * @param fileType - The type of file to export (e.g., CSV, Excel).\n   * @returns A Promise that resolves to a Blob representing the exported file.\n   */\n  async exportSeriesFile(fileType: string): Promise<Blob> {\n    const mergedExportDetails: MergedExportDetails = {\n      aggregation: this.exportConfig.aggregation,\n      dateFrom: this.exportConfig.dateFrom,\n      dateTo: this.exportConfig.dateTo\n    };\n\n    return this.datapointsExportSelectorFileExporterService.getSeriesExportedDataBlob(\n      fileType,\n      this.dataToExport,\n      mergedExportDetails\n    );\n  }\n\n  async onAggregationChange(aggregation: AggregationOption): Promise<void> {\n    this.exportConfig.aggregation = aggregation;\n    if (!this.isAggregationChangedProgrammatically) {\n      await this.updateExportConfigAndFetchData();\n      this.updateDownloadButtonState();\n    }\n  }\n\n  onDateFromChange(updatedDate: string): void {\n    this.dateFromSubject.next(updatedDate);\n  }\n\n  onDateToChange(updatedDate: string): void {\n    this.dateToSubject.next(updatedDate);\n  }\n\n  async updateDateAndFetchData(\n    dateType: 'dateFrom' | 'dateTo',\n    updatedDate: string\n  ): Promise<void> {\n    this.exportConfig[dateType] = updatedDate;\n    await this.updateExportConfigAndFetchData();\n\n    if (this.isFullTypeOfExport) {\n      await this.determineIfMeasurementResponseWillBeProcessedByBackend();\n    } else {\n      this.updateDownloadButtonState();\n    }\n  }\n\n  async onExportTypeChange(exportType: string): Promise<void> {\n    if (exportType === EXPORT_MODE_VALUES.full) {\n      this.isAggregationChangedProgrammatically = true;\n      this.formGroup.controls.aggregation.setValue(AGGREGATION_VALUES.none);\n      this.isAggregationChangedProgrammatically = false;\n\n      this.isFullTypeOfExport = true;\n      await this.updateExportConfigAndFetchData();\n      await this.determineIfMeasurementResponseWillBeProcessedByBackend();\n      return;\n    }\n\n    this.resetFullExportRelatedProperties();\n    this.isFullTypeOfExport = false;\n    await this.updateExportConfigAndFetchData();\n\n    this.updateDisabledAggregationOptionsState();\n\n    this.updateDownloadButtonState();\n  }\n\n  private updateDisabledAggregationOptionsState(): void {\n    this.disabledAggregationOptions =\n      this.datapointsExportSelectorFileExporterService.updateDisabledStateOfAggregationOptionEntries(\n        this.formGroup.controls.dateFrom.value,\n        this.formGroup.controls.dateTo.value,\n        this.disabledAggregationOptions\n      );\n  }\n\n  private createForm() {\n    return this.formBuilder.group(\n      {\n        dateFrom: new FormControl(this.exportConfig.dateFrom),\n        dateTo: new FormControl(this.exportConfig.dateTo),\n        aggregation: new FormControl(\n          this.exportConfig.aggregation ? this.exportConfig.aggregation : AGGREGATION_VALUES.none\n        ),\n        exportMode: new FormControl(EXPORT_MODE_VALUES.compact),\n        fileTypes: this.formBuilder.group(\n          this.generators.reduce((a, c) => {\n            a[c.getType()] = false;\n            return a;\n          }, {})\n        )\n      },\n      {\n        validators: [dateRangeValidator]\n      }\n    );\n  }\n\n  private preparePreview(): void {\n    this.isPreviewLoading = true;\n    this.previewTableData =\n      this.datapointsExportModalService.transformToExportFileStructureForPreview(this.dataToExport);\n    this.isPreviewLoading = false;\n  }\n\n  private handleDateSelectorChanges(): void {\n    const aggregationControl = this.formGroup.controls.aggregation;\n    const dateFromSelector = this.formGroup.controls.dateFrom;\n    const dateToSelector = this.formGroup.controls.dateTo;\n\n    const updateAggregationOptions = () => {\n      if (!this.isFullTypeOfExport) {\n        this.updateDisabledAggregationOptionsState();\n\n        const firstAvailableAggregationValue: AggregationOption =\n          this.datapointsExportSelectorFileExporterService.setToFirstAvailableAggregationOptionIfCurrentIsDisabled(\n            aggregationControl.value,\n            this.disabledAggregationOptions\n          );\n\n        if (firstAvailableAggregationValue) {\n          aggregationControl.setValue(firstAvailableAggregationValue);\n        }\n      }\n    };\n\n    merge(dateFromSelector.valueChanges, dateToSelector.valueChanges)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(updateAggregationOptions);\n  }\n\n  private handleExportModeChanges(): void {\n    const aggregationControl = this.formGroup.controls.aggregation;\n\n    this.formGroup.controls.exportMode.valueChanges\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(exportModeValue => {\n        if (exportModeValue.toString() === EXPORT_MODE_VALUES.full) {\n          aggregationControl.disable();\n        } else {\n          aggregationControl.enable();\n        }\n      });\n  }\n\n  private handleFileTypeSelectionChanges(): void {\n    this.formGroup.controls.fileTypes.valueChanges\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(fileTypesSelectionState => {\n        this.updateFileTypeSelectionState(fileTypesSelectionState);\n      });\n  }\n\n  private updateFileTypeSelectionState(checkboxesState: { [key: string]: boolean }): void {\n    this.isAnyOfExportFileTypeChecked = Object.values(checkboxesState).some(\n      value => value === true\n    );\n    this.fileTypeSelectionState = checkboxesState;\n    this.updateDownloadButtonState();\n  }\n\n  private handleFormValidationChanges(): void {\n    this.formGroup.statusChanges.pipe(takeUntil(this.destroy$)).subscribe(() => {\n      this.updateDownloadButtonState();\n    });\n  }\n\n  private updateFileTypeControl(): void {\n    const fileTypesControl = this.formGroup.controls.fileTypes;\n    if (fileTypesControl) {\n      const currentValue = fileTypesControl.value || {};\n      const updatedValue = { ...currentValue };\n\n      Object.entries(this.fileTypeSelectionState).forEach(([fileType, isSelected]) => {\n        if (fileType in currentValue) {\n          updatedValue[fileType] = isSelected;\n        }\n      });\n\n      fileTypesControl.patchValue(updatedValue);\n    }\n  }\n\n  private determineShowingPreviewOrEmptyState(): void {\n    const hasDataToShow = this.dataToExport.some(dataToExportItem =>\n      this.isFullTypeOfExport\n        ? !!dataToExportItem\n        : dataToExportItem.timeValueMap && Object.keys(dataToExportItem.timeValueMap).length > 0\n    );\n\n    this.hasFetchedDataAnyValuesToExport = hasDataToShow;\n\n    if (hasDataToShow) {\n      this.preparePreview();\n    } else {\n      this.isPreviewLoading = false;\n    }\n  }\n\n  private async determineIfMeasurementResponseWillBeProcessedByBackend(): Promise<void> {\n    this.isPreviewLoading = true;\n\n    this.datapointsExceedingBrowserDownloadLimit =\n      await this.datapointsExportSelectorService.getDatapointsExceedingLimit(this.exportConfig);\n\n    const { browserDownloadableCount, emailDeliverableCount, nonRetrievableCount } =\n      this.calculateDatapointCounts();\n\n    this.hasNoExportableData =\n      browserDownloadableCount === 0 && emailDeliverableCount === 0 && nonRetrievableCount > 0;\n\n    if (this.datapointsExceedingBrowserDownloadLimit.length > 0 && !this.hasNoExportableData) {\n      this.limitExceededMessage = this.datapointsExportSelectorService.getLimitExceededMessage(\n        this.hasNoExportableData,\n        emailDeliverableCount,\n        browserDownloadableCount,\n        nonRetrievableCount,\n        this.exportConfig.datapointDetails.length\n      );\n    }\n\n    if (this.datapointsExceedingBrowserDownloadLimit.length > 0 && this.hasNoExportableData) {\n      this.limitExceededMessage = this.datapointsExportSelectorService.getLimitExceededMessage(\n        this.hasNoExportableData\n      );\n    }\n\n    this.updateDownloadButtonState();\n\n    this.isPreviewLoading = false;\n  }\n\n  private calculateDatapointCounts(): DatapointCounts {\n    const RECORD_API_LIMIT = 1_000_000;\n\n    this.dataPointsExceedingOneMillionLimit = this.datapointsExceedingBrowserDownloadLimit.filter(\n      datapointsExceedingBrowserDownloadLimit =>\n        datapointsExceedingBrowserDownloadLimit.totalElements > RECORD_API_LIMIT\n    );\n\n    const nonRetrievableCount = this.dataPointsExceedingOneMillionLimit.length;\n\n    const emailDeliverableCount =\n      this.datapointsExceedingBrowserDownloadLimit.length - nonRetrievableCount;\n\n    const browserDownloadableCount =\n      this.exportConfig.datapointDetails.length - emailDeliverableCount - nonRetrievableCount;\n\n    return {\n      browserDownloadableCount,\n      emailDeliverableCount,\n      nonRetrievableCount\n    };\n  }\n\n  private storeInitialChangeableConfig(): void {\n    this.initialDateFrom = this.exportConfig.dateFrom;\n    this.initialDateTo = this.exportConfig.dateTo;\n    this.initialDatapointDetails = this.exportConfig.datapointDetails;\n    if (!this.isFullTypeOfExport) {\n      this.initialAggregation = this.exportConfig.aggregation;\n    }\n  }\n\n  private loadInitialChangeableConfig(): void {\n    this.exportConfig.dateFrom = this.initialDateFrom;\n    this.exportConfig.dateTo = this.initialDateTo;\n    this.exportConfig.datapointDetails = this.initialDatapointDetails;\n    if (!this.isFullTypeOfExport) {\n      this.exportConfig.aggregation = this.initialAggregation;\n    }\n  }\n\n  private async updateExportConfigAndFetchData(): Promise<void> {\n    if (this.formGroup.invalid) {\n      return;\n    }\n\n    this.isPreviewLoading = true;\n\n    this.onDownloadButtonStateChange.emit(false);\n    this.dataToExport = await this.datapointsExportSelectorService.fetchAndPrepareDataToExport(\n      this.exportConfig,\n      this.isFullTypeOfExport\n    );\n\n    this.determineShowingPreviewOrEmptyState();\n  }\n\n  private updateDownloadButtonState(): void {\n    const canEnableDownloadButton =\n      this.hasFetchedDataAnyValuesToExport &&\n      !this.formGroup.invalid &&\n      this.isAnyOfExportFileTypeChecked &&\n      !this.hasNoExportableData;\n\n    this.onDownloadButtonStateChange.emit(canEnableDownloadButton);\n  }\n\n  private resetFullExportRelatedProperties(): void {\n    this.hasNoExportableData = false;\n    this.datapointsExceedingBrowserDownloadLimit = [];\n  }\n\n  private getInitialSelection(\n    fileType: { [key: string]: FileTypeMetadata },\n    selectByDefault: number[]\n  ) {\n    const keys = Object.keys(fileType);\n    if (keys.length === 0) {\n      return {};\n    }\n\n    const initialSelection = keys.reduce<{ [key: string]: boolean }>((acc, key) => {\n      acc[key] = false;\n      return acc;\n    }, {});\n\n    selectByDefault.forEach(index => {\n      if (index >= 0 && index < keys.length) {\n        initialSelection[keys[index]] = true;\n      }\n    });\n\n    return initialSelection;\n  }\n}\n","<div class=\"p-b-16\">\n  <ng-container *ngIf=\"hasPermissionToReadAnyMeasurements; else hasNoRoleToReadAnyMeasurements\">\n    <div class=\"p-16 text-center separator-bottom sticky-top bg-component\">\n      <p class=\"text-medium text-16\">\n        {{ 'Configure export' | translate }}\n      </p>\n    </div>\n    <div\n      class=\"p-t-24 p-r-16 p-l-16 gap-8 p-b-16 flex-wrap\"\n      [ngClass]=\"{ 'separator-bottom': isFullTypeOfExport }\"\n    >\n      <div class=\"row\">\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-time-range\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [formGroup]=\"formGroup\"\n            (onDateFromChange)=\"onDateFromChange($event)\"\n            (onDateToChange)=\"onDateToChange($event)\"\n          ></c8y-datapoints-export-selector-time-range>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-data-scope\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [disabledAggregationOptions]=\"disabledAggregationOptions\"\n            [formGroup]=\"formGroup\"\n            (onAggregationChange)=\"onAggregationChange($event)\"\n            (onExportTypeChange)=\"onExportTypeChange($event)\"\n          ></c8y-datapoints-export-selector-data-scope>\n        </div>\n        <div class=\"col-md-4\">\n          <c8y-datapoints-export-selector-file-types\n            *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n            [dynamicFilesTypeMetadata]=\"dynamicFilesTypeMetadata\"\n            [formGroup]=\"formGroup\"\n          ></c8y-datapoints-export-selector-file-types>\n        </div>\n      </div>\n    </div>\n    <ng-container\n      *ngIf=\"!isFullTypeOfExport && !hasFetchedDataAnyValuesToExport && !isPreviewLoading\"\n    >\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          class=\"alert alert-warning center-block\"\n          role=\"alert\"\n          data-cy=\"file-exporter--no-data-available\"\n          translate\n        >\n          No data available.\n        </div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"datapointsExceedingBrowserDownloadLimit.length > 0\">\n      <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 separator-bottom d-flex\">\n        <div\n          [class]=\"\n            hasNoExportableData\n              ? 'alert alert-warning center-block'\n              : 'alert alert-info center-block'\n          \"\n          role=\"alert\"\n          [innerHTML]=\"limitExceededMessage\"\n        ></div>\n      </div>\n    </ng-container>\n    <ng-container *ngIf=\"isFullTypeOfExport\">\n      <c8y-datapoints-export-selector-preview\n        *ngIf=\"this.hasPermissionToReadAnyMeasurements\"\n        [hasFetchedDataAnyValuesToExport]=\"hasFetchedDataAnyValuesToExport\"\n        [isPreviewLoading]=\"isPreviewLoading\"\n        [previewTableData]=\"previewTableData\"\n      ></c8y-datapoints-export-selector-preview>\n    </ng-container>\n  </ng-container>\n  <ng-template #hasNoRoleToReadAnyMeasurements>\n    <div class=\"p-t-24 p-r-16 p-l-16 p-b-16 d-flex\">\n      <div\n        class=\"alert alert-info center-block\"\n        role=\"alert\"\n        translate\n      >\n        <p>To export data, you must meet at least one of these criteria:</p>\n        <ul>\n          <li>\n            Have\n            <b>READ permission for \"Measurements\" permission type</b>\n            (either as a global role or for the specific source)\n          </li>\n          <li>\n            Be the\n            <b>owner of the source</b>\n            you want to export data from\n          </li>\n        </ul>\n        <p>Don't meet these requirements? Contact your system administrator for assistance.</p>\n      </div>\n    </div>\n  </ng-template>\n</div>\n"]}