@microsoft/windows-admin-center-sdk/angular/esm2020/src/controls/data-table/data-table-download.service.mjs

Microsoft - Windows Admin Center Shell

import { EventEmitter, Injectable } from '@angular/core';
import { LogLevel } from '@microsoft/windows-admin-center-sdk/core/diagnostics/log-level';
import { Logging } from '@microsoft/windows-admin-center-sdk/core/diagnostics/logging';
import { interval, throwError, timer } from 'rxjs';
import { delay, filter, take, takeUntil, takeWhile } from 'rxjs/operators';
import { AppContextService } from '../../service/app-context.service';
import * as i0 from "@angular/core";
import * as i1 from "../../service/app-context.service";
export var DataTableDownloadDataType;
(function (DataTableDownloadDataType) {
    DataTableDownloadDataType["CSV"] = "text/csv";
    DataTableDownloadDataType["JSON"] = "application/json";
})(DataTableDownloadDataType || (DataTableDownloadDataType = {}));
export class DataTableDownloadService {
    constructor(appContextService) {
        this.appContextService = appContextService;
        /**
         * The localization strings object for master view.
         */
        this.resourceStrings = MsftSme.self().Resources.strings.MsftSmeShell.Angular.DataTable.DownloadService;
        /**
         * The download finished event emitter.
         */
        this.downloadDataFinished = new EventEmitter();
        /**
         * Determines if one download service is ongoing.
         */
        this.isBusy = false;
        /**
         * Adding a force delay time can help with general performance of the downloading function when dataset grows big.
         * It can also help with improve granularity for notification state changes.
         */
        this.minDownloadDelayTime = 1000;
        /**
         * Force timeout 2mins.
         */
        this.maxDownloadTimeAllowed = 120000;
        this.moduleName = MsftSme.self().Init.moduleName;
    }
    ngOnDestroy() {
        this.worker?.terminate();
    }
    /*
     * The download data from data table component function.
     * @param dataTable The data table component to download data from.
     * @param downloadType The type of data to be downloaded.
     * @param contextParameters The context parameters from outside of the data table component from the extension.
     */
    downloadData(dataTable, downloadType, contextParameters) {
        this.notificationInstance = this.appContextService.notification.create(this.appContextService.gateway.gatewayName);
        const inProgressTitle = this.resourceStrings.inProgressTitle;
        const inProgressContent = this.resourceStrings.inProgressContent.format(this.moduleName);
        const successTitle = this.resourceStrings.successTitle;
        const successContent = this.resourceStrings.successContent.format(this.moduleName);
        const failedTitle = this.resourceStrings.failedTitle;
        this.notificationInstance.showInProgress(inProgressTitle, inProgressContent);
        this.isBusy = true;
        this.downloadDataCore(dataTable, downloadType, contextParameters).pipe(take(1)).subscribe({
            error: error => {
                Logging.log({
                    level: LogLevel.Warning,
                    message: `Download failed: ${error}`,
                    source: 'MasterViewComponent.onDownloadButtonClicked()'
                });
                const failedContent = this.resourceStrings.failedContent.format(this.moduleName, error);
                this.notificationInstance.showError(failedTitle, failedContent);
                this.worker.terminate();
                this.downloadDataFinished.emit();
            },
            complete: () => {
                this.notificationInstance.showSuccess(successTitle, successContent);
                this.downloadDataFinished.emit();
            }
        });
    }
    /**
     * It guarantees the valid DataTableDownloadDataType is passed in to the worker.
     * @param downloadType the downloadType passed in from client side that needs validation.
     * @returns a valid downloadType that comes from DataTableDownloadDataType
     */
    validateMimeType(downloadType) {
        return Object.values(DataTableDownloadDataType).includes(downloadType) ? downloadType : DataTableDownloadDataType.CSV;
    }
    /**
     * The actual implementation core function for download data.
     * @param dataTable the data table component reference.
     * @param downloadType the downloadType passed in from client.
     * @returns parsed error in string.
     */
    downloadDataCore(dataTable, downloadType, contextParameters) {
        const data = JSON.parse(JSON.stringify(dataTable.items));
        const type = this.validateMimeType(downloadType);
        const fileName = this.moduleName ? `${this.moduleName}-${new Date().getTime().toString()}.csv` : new Date().getTime().toString();
        this.initWorker(type);
        this.worker.postMessage({ data, type });
        this.worker.onmessage = (event) => {
            let processedData = '';
            try {
                if (downloadType === DataTableDownloadDataType.CSV) {
                    // Download rendered content from the table in CSV.
                    processedData = this.convertToCsv(event.data.processedData, dataTable, contextParameters);
                }
                else {
                    // Download RAW JSON.
                    processedData = JSON.stringify(event.data.processedData);
                }
                this.downloadAction(processedData, type, fileName);
                this.isBusy = false;
            }
            catch (e) {
                this.isBusy = false;
                return throwError(() => e.toString()).pipe(delay(this.minDownloadDelayTime));
            }
        };
        return interval(this.minDownloadDelayTime).pipe(takeUntil(timer(this.maxDownloadTimeAllowed)), takeWhile(() => this.isBusy, true), filter(() => !this.isBusy));
    }
    downloadAction(data, mimeType, fileName) {
        const blob = new Blob([data], { type: mimeType });
        const url = URL.createObjectURL(blob);
        const link = document.createElement('a');
        link.href = url;
        link.download = fileName;
        link.click();
        URL.revokeObjectURL(url);
    }
    convertToCsv(dataList, dataTable, contextParameters) {
        const columns = dataTable.actualColumns.map(column => {
            return {
                field: column.field,
                header: column.header,
                hasTemplate: !!column.bodyTemplate,
                downloadContentProcessor: column.downloadContentProcessor ?? undefined
            };
        });
        const rows = [columns.map((column) => column.header).join(',')];
        const errors = [];
        dataList.forEach((dataItem, rowIndex) => {
            const values = columns.map((column, columnIndex) => {
                // Resolve nested object and get value.
                let value = dataTable.resolveObjectPath(dataItem, column.field);
                if (column.hasTemplate) {
                    if (column.downloadContentProcessor) {
                        // Process the data by passed in function.
                        value = column.downloadContentProcessor(value, dataItem, contextParameters);
                        // Wrap the string with double quote and still maintain valid string to prevent
                        // being recognized as separate columns from csv file.
                        if (typeof value !== 'string') {
                            try {
                                value = this.castToString(value);
                            }
                            catch (e) {
                                throw new Error(`Failed to cast ${value} to string ${e}`);
                            }
                        }
                        value = this.preventTextContentAsSeparatedColumns(value);
                    }
                    else {
                        if (!errors.includes(column['header'])) {
                            errors.push(column['header']);
                        }
                        value = this.getTableCellRenderedString(rowIndex, columnIndex, dataTable);
                    }
                }
                return value;
            });
            rows.push(values.join(','));
        });
        // Error handling.
        if (errors && errors.length) {
            throw new Error('Please add \'downloadContentProcessor\' function to listed field(s): ' + errors.join(','));
        }
        return rows.join('\r\n');
    }
    /**
     * It converts any type to string.
     * @param input any type of input.
     * @returns the string representation for input.
     */
    castToString(input) {
        if (input === null || typeof input === 'undefined') {
            return '';
        }
        if (typeof input === 'object' || typeof input === 'function') {
            return JSON.stringify(input);
        }
        return String(input);
    }
    /**
     * Prevents space to be recognized as different columns.
     * The solution is to wrap the string with double quote and still forms a valid string.
     * @param value The input string that needs to wrap with double quote.
     * @returns the string wrapped with double quotes and is still a valid string.
     */
    preventTextContentAsSeparatedColumns(value) {
        if (value === undefined || value === null) {
            return '""'; // Return empty double quotes for undefined or null values
        }
        return '"' + value.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
    }
    /**
     * It gets the rendered string from the rendered table row and cell.
     * @param rowIndex the row index from the data table.
     * @param columnIndex the column index from the data table.
     * @param dataTable the data table component reference.
     * @returns the string representing the rendered data from DOM.
     */
    getTableCellRenderedString(rowIndex, columnIndex, dataTable) {
        if (!dataTable) {
            return;
        }
        const cells = dataTable.getTableCells(rowIndex);
        const cell = cells[columnIndex];
        return cell?.textContent.trim() ?? '';
    }
    /**
     * The initialization for the worker to be used for downloading data table text content.
     */
    initWorker(type) {
        const downloadWorkerFunction = `
            self.onmessage = function(event) {
                const { data, type } = event.data;
                const processedData = data;
                self.postMessage({ processedData });
            };
        `;
        const workerBlob = new Blob([downloadWorkerFunction], { type });
        const workerUrl = URL.createObjectURL(workerBlob);
        this.worker = new Worker(workerUrl);
    }
}
/** @nocollapse */ DataTableDownloadService.ɵfac = function DataTableDownloadService_Factory(t) { return new (t || DataTableDownloadService)(i0.ɵɵinject(i1.AppContextService)); };
/** @nocollapse */ DataTableDownloadService.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: DataTableDownloadService, factory: DataTableDownloadService.ɵfac });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DataTableDownloadService, [{
        type: Injectable
    }], function () { return [{ type: i1.AppContextService }]; }, null); })();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table-download.service.js","sourceRoot":"","sources":["../../../../../../../../angular/src/controls/data-table/data-table-download.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable, OnDestroy } from '@angular/core';\r\nimport { LogLevel } from '@microsoft/windows-admin-center-sdk/core/diagnostics/log-level';\r\nimport { Logging } from '@microsoft/windows-admin-center-sdk/core/diagnostics/logging';\r\nimport { ClientNotificationInstance } from '@microsoft/windows-admin-center-sdk/core/index';\r\nimport { interval, Observable, throwError, timer } from 'rxjs';\r\nimport { delay, filter, take, takeUntil, takeWhile } from 'rxjs/operators';\r\nimport { AppContextService } from '../../service/app-context.service';\r\nimport { DataTableComponent } from './data-table.component';\r\n\r\nexport enum DataTableDownloadDataType {\r\n    CSV = 'text/csv',\r\n    JSON = 'application/json'\r\n}\r\n\r\n@Injectable()\r\nexport class DataTableDownloadService implements OnDestroy {\r\n    /**\r\n     * The localization strings object for master view.\r\n     */\r\n    public resourceStrings = MsftSme.self().Resources.strings.MsftSmeShell.Angular.DataTable.DownloadService;\r\n\r\n    /**\r\n     * The download finished event emitter.\r\n     */\r\n    public downloadDataFinished: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n    /**\r\n     * The notification instance.\r\n     */\r\n    private notificationInstance: ClientNotificationInstance;\r\n\r\n    /**\r\n     * The download worker.\r\n     */\r\n    private worker: Worker;\r\n\r\n    /**\r\n     * The current extension/module fileName.\r\n     */\r\n    private moduleName: string;\r\n\r\n    /**\r\n     * Determines if one download service is ongoing.\r\n     */\r\n    private isBusy = false;\r\n\r\n    /**\r\n     * Adding a force delay time can help with general performance of the downloading function when dataset grows big.\r\n     * It can also help with improve granularity for notification state changes.\r\n     */\r\n    private readonly minDownloadDelayTime = 1000;\r\n\r\n    /**\r\n     * Force timeout 2mins.\r\n     */\r\n    private readonly maxDownloadTimeAllowed = 120000;\r\n\r\n    constructor(private appContextService: AppContextService) {\r\n        this.moduleName = MsftSme.self().Init.moduleName;\r\n    }\r\n\r\n    public ngOnDestroy(): void {\r\n        this.worker?.terminate();\r\n    }\r\n\r\n    /*\r\n     * The download data from data table component function.\r\n     * @param dataTable The data table component to download data from.\r\n     * @param downloadType The type of data to be downloaded.\r\n     * @param contextParameters The context parameters from outside of the data table component from the extension.\r\n     */\r\n    public downloadData(dataTable: DataTableComponent, downloadType: DataTableDownloadDataType, contextParameters?: any): void {\r\n        this.notificationInstance = this.appContextService.notification.create(this.appContextService.gateway.gatewayName);\r\n        const inProgressTitle = this.resourceStrings.inProgressTitle;\r\n        const inProgressContent = this.resourceStrings.inProgressContent.format(this.moduleName);\r\n        const successTitle = this.resourceStrings.successTitle;\r\n        const successContent = this.resourceStrings.successContent.format(this.moduleName);\r\n        const failedTitle = this.resourceStrings.failedTitle;\r\n\r\n        this.notificationInstance.showInProgress(\r\n            inProgressTitle,\r\n            inProgressContent\r\n        );\r\n\r\n        this.isBusy = true;\r\n\r\n        this.downloadDataCore(dataTable, downloadType, contextParameters).pipe(take(1)).subscribe({\r\n            error: error => {\r\n                Logging.log({\r\n                    level: LogLevel.Warning,\r\n                    message: `Download failed: ${error}`,\r\n                    source: 'MasterViewComponent.onDownloadButtonClicked()'\r\n                });\r\n\r\n                const failedContent = this.resourceStrings.failedContent.format(this.moduleName, error);\r\n\r\n                this.notificationInstance.showError(\r\n                    failedTitle,\r\n                    failedContent\r\n                );\r\n\r\n                this.worker.terminate();\r\n\r\n                this.downloadDataFinished.emit();\r\n            },\r\n            complete: () => {\r\n                this.notificationInstance.showSuccess(\r\n                    successTitle,\r\n                    successContent\r\n                );\r\n\r\n                this.downloadDataFinished.emit();\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * It guarantees the valid DataTableDownloadDataType is passed in to the worker.\r\n     * @param downloadType the downloadType passed in from client side that needs validation.\r\n     * @returns a valid downloadType that comes from DataTableDownloadDataType\r\n     */\r\n    private validateMimeType(downloadType: DataTableDownloadDataType): DataTableDownloadDataType {\r\n        return Object.values(DataTableDownloadDataType).includes(downloadType) ? downloadType : DataTableDownloadDataType.CSV;\r\n    }\r\n\r\n    /**\r\n     * The actual implementation core function for download data.\r\n     * @param dataTable the data table component reference.\r\n     * @param downloadType the downloadType passed in from client.\r\n     * @returns parsed error in string.\r\n     */\r\n    private downloadDataCore(\r\n        dataTable: DataTableComponent,\r\n        downloadType: DataTableDownloadDataType,\r\n        contextParameters?: any\r\n    ): Observable<any> {\r\n        const data = JSON.parse(JSON.stringify(dataTable.items));\r\n        const type = this.validateMimeType(downloadType);\r\n        const fileName = this.moduleName ? `${this.moduleName}-${new Date().getTime().toString()}.csv` : new Date().getTime().toString();\r\n\r\n        this.initWorker(type);\r\n\r\n        this.worker.postMessage({ data, type });\r\n\r\n        this.worker.onmessage = (event) => {\r\n            let processedData = '';\r\n            try {\r\n                if (downloadType === DataTableDownloadDataType.CSV) {\r\n                    // Download rendered content from the table in CSV.\r\n                    processedData = this.convertToCsv(event.data.processedData, dataTable, contextParameters);\r\n                } else {\r\n                    // Download RAW JSON.\r\n                    processedData = JSON.stringify(event.data.processedData);\r\n                }\r\n\r\n                this.downloadAction(processedData, type, fileName);\r\n                this.isBusy = false;\r\n            } catch (e) {\r\n                this.isBusy = false;\r\n                return throwError(() => e.toString()).pipe(delay(this.minDownloadDelayTime));\r\n            }\r\n        };\r\n\r\n        return interval(this.minDownloadDelayTime).pipe(\r\n            takeUntil(timer(this.maxDownloadTimeAllowed)),\r\n            takeWhile(() => this.isBusy, true),\r\n            filter(() => !this.isBusy)\r\n          );\r\n    }\r\n\r\n    private downloadAction(data: string, mimeType: string, fileName: string) {\r\n        const blob = new Blob([data], { type: mimeType });\r\n        const url = URL.createObjectURL(blob);\r\n        const link = document.createElement('a');\r\n\r\n        link.href = url;\r\n        link.download = fileName;\r\n        link.click();\r\n\r\n        URL.revokeObjectURL(url);\r\n    }\r\n\r\n    private convertToCsv(dataList: any[], dataTable: DataTableComponent, contextParameters?: any): string {\r\n        const columns = dataTable.actualColumns.map(column => {\r\n            return {\r\n                field: column.field,\r\n                header: column.header,\r\n                hasTemplate: !!column.bodyTemplate,\r\n                downloadContentProcessor: column.downloadContentProcessor ?? undefined\r\n            };\r\n        });\r\n        const rows = [columns.map((column) => column.header).join(',')];\r\n        const errors = [];\r\n\r\n        dataList.forEach((dataItem, rowIndex) => {\r\n            const values = columns.map((column, columnIndex) => {\r\n                // Resolve nested object and get value.\r\n                let value = dataTable.resolveObjectPath(dataItem, column.field);\r\n\r\n                if (column.hasTemplate) {\r\n                    if (column.downloadContentProcessor) {\r\n                        // Process the data by passed in function.\r\n                        value = column.downloadContentProcessor(value, dataItem, contextParameters);\r\n                        // Wrap the string with double quote and still maintain valid string to prevent\r\n                        // being recognized as separate columns from csv file.\r\n                        if (typeof value !== 'string') {\r\n                            try {\r\n                                value = this.castToString(value);\r\n                            } catch (e) {\r\n                                throw new Error(`Failed to cast ${value} to string ${e}`);\r\n                            }\r\n                        }\r\n\r\n                        value = this.preventTextContentAsSeparatedColumns(value);\r\n                    } else {\r\n                        if (!errors.includes(column['header'])) {\r\n                            errors.push(column['header']);\r\n                        }\r\n                        value = this.getTableCellRenderedString(rowIndex, columnIndex, dataTable);\r\n                    }\r\n                }\r\n\r\n                return value;\r\n            });\r\n            rows.push(values.join(','));\r\n        });\r\n\r\n        // Error handling.\r\n        if (errors && errors.length) {\r\n            throw new Error('Please add \\'downloadContentProcessor\\' function to listed field(s): ' + errors.join(','));\r\n        }\r\n\r\n        return rows.join('\\r\\n');\r\n    }\r\n\r\n    /**\r\n     * It converts any type to string.\r\n     * @param input any type of input.\r\n     * @returns the string representation for input.\r\n     */\r\n    private castToString(input: any): string {\r\n        if (input === null || typeof input === 'undefined') {\r\n            return '';\r\n        }\r\n\r\n        if (typeof input === 'object' || typeof input === 'function') {\r\n            return JSON.stringify(input);\r\n        }\r\n\r\n        return String(input);\r\n    }\r\n\r\n    /**\r\n     * Prevents space to be recognized as different columns.\r\n     * The solution is to wrap the string with double quote and still forms a valid string.\r\n     * @param value The input string that needs to wrap with double quote.\r\n     * @returns the string wrapped with double quotes and is still a valid string.\r\n     */\r\n    private preventTextContentAsSeparatedColumns(value: string): string {\r\n        if (value === undefined || value === null) {\r\n            return '\"\"'; // Return empty double quotes for undefined or null values\r\n        }\r\n        return '\"' + value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"') + '\"';\r\n    }\r\n\r\n    /**\r\n     * It gets the rendered string from the rendered table row and cell.\r\n     * @param rowIndex the row index from the data table.\r\n     * @param columnIndex the column index from the data table.\r\n     * @param dataTable the data table component reference.\r\n     * @returns the string representing the rendered data from DOM.\r\n     */\r\n    private getTableCellRenderedString(rowIndex: number, columnIndex: number, dataTable: DataTableComponent): string {\r\n        if (!dataTable) {\r\n            return;\r\n        }\r\n\r\n        const cells = dataTable.getTableCells(rowIndex);\r\n        const cell = cells[columnIndex];\r\n        return cell?.textContent.trim() ?? '';\r\n    }\r\n\r\n    /**\r\n     * The initialization for the worker to be used for downloading data table text content.\r\n     */\r\n    private initWorker(type: string): void {\r\n        const downloadWorkerFunction = `\r\n            self.onmessage = function(event) {\r\n                const { data, type } = event.data;\r\n                const processedData = data;\r\n                self.postMessage({ processedData });\r\n            };\r\n        `;\r\n\r\n        const workerBlob = new Blob([downloadWorkerFunction], { type });\r\n        const workerUrl = URL.createObjectURL(workerBlob);\r\n        this.worker = new Worker(workerUrl);\r\n    }\r\n}\r\n"]}