@ieeesa-npm/groups 0.15.3 → 0.15.5

package/esm2022/lib/services/roster-export.service.mjs

@@ -0,0 +1,396 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { BehaviorSubject, EMPTY, Subject, takeUntil } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { saveAs } from 'file-saver';
+import { ExportFormat, PolicyConfirmationDialogComponent, ExportSuccessDialogComponent, } from '@ieeesa-npm/presentation';
+import { AlertType } from '@ieeesa-npm/models';
+import * as screenTexts from '../assets/constants.json';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "@ieeesa-npm/utility";
+/**
+ * RosterExportService owns the complete group roster export flow:
+ * 1. Manages export popover open/close state
+ * 2. Opens IEEE Data Access and Use Policy confirmation dialog
+ * 3. Calls the backend roster export API (blob response)
+ * 4. Triggers file download via File System Access API / file-saver
+ * 5. Shows success/error dialogs and toasts
+ *
+ * The component only needs to:
+ * - Subscribe to `isPopoverOpen$` for popover visibility
+ * - Call `togglePopover()` on Export button click
+ * - Call `onFormatSelected(format, groupId, groupName)` when user picks a format
+ *
+ * Follows the same pattern as MeetingExportService in the events-and-meetings library.
+ * @export
+ * @class RosterExportService
+ */
+export class RosterExportService {
+    constructor(
+    // eslint-disable-next-line no-unused-vars
+    httpClient, 
+    // eslint-disable-next-line no-unused-vars
+    dialog, 
+    // eslint-disable-next-line no-unused-vars
+    alertService) {
+        this.httpClient = httpClient;
+        this.dialog = dialog;
+        this.alertService = alertService;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.constants = screenTexts;
+        this.destroy$ = new Subject();
+        /** Controls popover open/close state */
+        this.isPopoverOpenSubject$ = new BehaviorSubject(false);
+        this.isPopoverOpen$ = this.isPopoverOpenSubject$.asObservable();
+        /** Controls in-progress state for button disable */
+        this.isExportInProgressSubject$ = new BehaviorSubject(false);
+        this.isExportInProgress$ = this.isExportInProgressSubject$.asObservable();
+        /** Format options for the export popover */
+        this.exportFormatOptions = [
+            {
+                label: this.constants?.rosterExport?.formatOptions?.csv?.label ?? 'CSV',
+                value: ExportFormat.CSV,
+                ariaLabel: this.constants?.rosterExport?.formatOptions?.csv?.ariaLabel ?? 'Export roster as CSV',
+            },
+            {
+                label: this.constants?.rosterExport?.formatOptions?.excel?.label ?? 'Excel',
+                value: ExportFormat.EXCEL,
+                ariaLabel: this.constants?.rosterExport?.formatOptions?.excel?.ariaLabel ?? 'Export roster as Excel',
+            },
+        ];
+        /** Subtitle labels for the format selection cards */
+        this.exportFormatSubtitles = {
+            csv: this.constants?.rosterExport?.formatOptions?.csv?.subtitle ?? 'Comma separated file',
+            xls: this.constants?.rosterExport?.formatOptions?.excel?.subtitle ?? 'Spreadsheet File',
+        };
+        /** Popover title */
+        this.popoverTitle = this.constants?.rosterExport?.popoverTitle ?? 'Select the file format for roster export.';
+    }
+    /**
+     * Sets the API base URL for roster export calls.
+     * @param {string} url - Base URL (e.g., 'https://saappsapidev.ieee.org/v1')
+     * @memberof RosterExportService
+     */
+    setApiBaseUrl(url) {
+        this.apiBaseUrl = url;
+    }
+    /**
+     * Toggles the export format popover open/closed.
+     * Called by the component on Export button click.
+     * @memberof RosterExportService
+     */
+    togglePopover() {
+        this.isPopoverOpenSubject$.next(!this.isPopoverOpenSubject$.getValue());
+    }
+    /**
+     * Closes the export format popover.
+     * @memberof RosterExportService
+     */
+    closePopover() {
+        this.isPopoverOpenSubject$.next(false);
+    }
+    /**
+     * Handles format selection from the export popover.
+     * Closes popover, opens IEEE Policy dialog, on confirm triggers export.
+     * This is the main entry point called by the component after user picks a format.
+     * @param {ExportFormat} format - Selected format (CSV or XLS)
+     * @param {string} groupId - The group ID to export the roster for
+     * @param {string} groupName - The group name for filename generation
+     * @memberof RosterExportService
+     */
+    onFormatSelected(format, groupId, groupName) {
+        this.closePopover();
+        const dialogData = {
+            title: this.constants?.rosterExport?.policyDialog?.title ?? 'IEEE Data Access and Use Policy',
+            bodyText: this.constants?.rosterExport?.policyDialog?.bodyText ?? 'The application is governed by IEEE\'s data access and use policy. Data can only be used for its original intended purpose. Click "Confirm" to export the data into a CSV/Excel file or click "Cancel" to cancel the download.',
+            policyUrl: this.constants?.rosterExport?.policyDialog?.policyUrl ?? 'https://www.ieee.org/ieee-data-access-and-use-policy.html',
+            policyLinkText: this.constants?.rosterExport?.policyDialog?.policyLinkText ?? 'data access and use policy',
+            cancelLabel: this.constants?.rosterExport?.policyDialog?.cancelLabel ?? 'Cancel',
+            confirmLabel: this.constants?.rosterExport?.policyDialog?.confirmLabel ?? 'Confirm',
+        };
+        const dialogRef = this.dialog.open(PolicyConfirmationDialogComponent, {
+            data: dialogData,
+            width: '637px',
+            panelClass: ['ieeesa-policy-dialog'],
+        });
+        dialogRef.afterClosed()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((confirmed) => {
+            if (confirmed) {
+                this.startExport(format, groupId, groupName);
+            }
+        });
+    }
+    /**
+     * Starts the export after the user confirms the policy dialog.
+     *
+     * When the File System Access API is available, the native Save picker is opened
+     * HERE — synchronously within the confirm handler — while the user activation from
+     * the confirm click is still valid. (Opening it later, inside the async HTTP
+     * response callback, would exceed the activation window and the browser would
+     * reject it with a SecurityError.) The obtained file handle is then passed to the
+     * HTTP flow, which writes the downloaded bytes to it once the response arrives, so
+     * the success dialog is still shown only AFTER the file is saved.
+     *
+     * If the user cancels the picker we abort before making the request. If the API is
+     * unavailable (Firefox/Safari) we proceed without a handle and fall back to
+     * `saveAs()` after the response.
+     * @param {ExportFormat} format
+     * @param {string} groupId
+     * @param {string} groupName
+     * @memberof RosterExportService
+     */
+    startExport(format, groupId, groupName) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const showSaveFilePicker = window.showSaveFilePicker;
+        if (typeof showSaveFilePicker !== 'function') {
+            // API unavailable: no handle; executeExport() will use the saveAs() fallback.
+            this.executeExport(format, groupId, groupName, null);
+            return;
+        }
+        const mimeType = format === ExportFormat.CSV
+            ? 'text/csv'
+            : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        const extension = format === ExportFormat.CSV ? '.csv' : '.xlsx';
+        const suggestedName = this.buildFilename(groupName, format);
+        // Open the picker now, while the confirm-click activation is still valid.
+        showSaveFilePicker({
+            suggestedName,
+            types: [
+                {
+                    description: format === ExportFormat.CSV ? 'CSV File' : 'Excel File',
+                    accept: { [mimeType]: [extension] },
+                },
+            ],
+        })
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .then((handle) => {
+            this.executeExport(format, groupId, groupName, handle);
+        })
+            .catch((error) => {
+            // User cancelled the Save dialog — abort silently, no request made.
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                return;
+            }
+            // Any other picker error: fall back to the saveAs() flow.
+            this.executeExport(format, groupId, groupName, null);
+        });
+    }
+    /**
+     * Executes the roster export API call and writes the downloaded file.
+     * Endpoint: GET /v1/groups/roster/export/{groupId}?format=csv|xlsx
+     * When a pre-obtained file handle is provided (from the picker opened at confirm
+     * time) the bytes are written to it; otherwise it falls back to `saveAs()`.
+     * The success dialog is shown only after the file has been written.
+     * @param {ExportFormat} format - The selected export format
+     * @param {string} groupId - The group identifier
+     * @param {string} groupName - The group name for filename
+     * @param {FileSystemFileHandle | null} fileHandle - Handle from the Save picker, or null
+     * @memberof RosterExportService
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    executeExport(format, groupId, groupName, fileHandle) {
+        this.isExportInProgressSubject$.next(true);
+        // Backend expects 'csv' or 'xlsx'. The ExportFormat.EXCEL enum value is
+        // 'xls', so it must be mapped to 'xlsx' here — sending 'xls' is rejected
+        // with error code 1079.
+        const formatValue = format === ExportFormat.CSV ? 'csv' : 'xlsx';
+        const params = new HttpParams().set('format', formatValue);
+        const url = `${this.getExportApiUrl()}/groups/roster/export/${groupId}`;
+        this.httpClient
+            .get(url, {
+            params,
+            responseType: 'blob',
+            observe: 'response',
+        })
+            .pipe(map((response) => {
+            const filename = this.extractFilenameFromResponse(response, format, groupName);
+            return { blob: response.body, filename };
+        }), catchError(() => {
+            this.isExportInProgressSubject$.next(false);
+            this.alertService.showMessage({
+                status: 'custom',
+                message: this.constants?.rosterExport?.messages?.exportFailed ?? 'Failed to export roster. Please try again.',
+                alertType: AlertType.ERROR,
+                isCloseNeeded: true,
+            });
+            // Error is fully handled (alert shown). Complete the stream instead of
+            // rethrowing, so the next-only subscribe does not report it as an
+            // unhandled RxJS error.
+            return EMPTY;
+        }), takeUntil(this.destroy$))
+            .subscribe({
+            next: (result) => {
+                // Write to the pre-obtained handle (picker opened at confirm time) or fall
+                // back to saveAs(). Success dialog only shows after the file is written.
+                this.downloadFile(result.blob, result.filename, format, fileHandle)
+                    .then(({ saved }) => {
+                    this.isExportInProgressSubject$.next(false);
+                    if (saved) {
+                        this.showExportSuccessDialogAfterDownload(result.filename);
+                    }
+                })
+                    .catch(() => {
+                    this.isExportInProgressSubject$.next(false);
+                    this.alertService.showMessage({
+                        status: 'custom',
+                        message: this.constants?.rosterExport?.messages?.exportFailed ?? 'Failed to export roster. Please try again.',
+                        alertType: AlertType.ERROR,
+                        isCloseNeeded: true,
+                    });
+                });
+            },
+        });
+    }
+    /**
+     * Shows the export success dialog after a successful file download.
+     * @param {string} filename - The downloaded filename
+     * @memberof RosterExportService
+     */
+    showExportSuccessDialogAfterDownload(filename) {
+        const successMessage = this.constants?.rosterExport?.successDialog?.message ?? 'The file was downloaded successfully.';
+        const closeLabel = this.constants?.rosterExport?.successDialog?.closeButton ?? 'Close';
+        const dialogData = {
+            message: successMessage,
+            filename,
+            closeLabel,
+        };
+        this.dialog.open(ExportSuccessDialogComponent, {
+            data: dialogData,
+            width: '467px',
+            panelClass: ['ieeesa-export-success-dialog-panel'],
+            autoFocus: false,
+        });
+    }
+    /**
+     * Returns the API base URL for roster export.
+     * @return {string}
+     * @memberof RosterExportService
+     */
+    getExportApiUrl() {
+        if (!this.apiBaseUrl) {
+            throw new Error('RosterExportService apiBaseUrl is not set. Call setApiBaseUrl() before export.');
+        }
+        // apiBaseUrl already carries the version segment (e.g. '.../v1'), same as every
+        // other GroupsService call which is built as `${apiBaseUrl}/groups/...`. So the
+        // caller only appends '/groups/roster/export/{groupId}' — the version is NOT
+        // repeated here. Strip a trailing slash to avoid a double slash before '/groups'.
+        return this.apiBaseUrl.replace(/\/+$/, '');
+    }
+    /**
+     * Extracts filename from Content-Disposition header.
+     * Falls back to buildFilename() if header is missing.
+     * @param {HttpResponse<Blob>} response
+     * @param {ExportFormat} format
+     * @param {string} groupName
+     * @return {string}
+     * @memberof RosterExportService
+     */
+    extractFilenameFromResponse(response, format, groupName) {
+        const contentDisposition = response.headers.get('Content-Disposition');
+        if (contentDisposition) {
+            const filenameMatch = contentDisposition.match(/filename="?([^"]+)"?/);
+            if (filenameMatch && filenameMatch[1]) {
+                return filenameMatch[1].replace(/[/\\:*?"<>|]/g, '_').substring(0, 200);
+            }
+        }
+        return this.buildFilename(groupName, format);
+    }
+    /**
+     * Builds a sanitized filename for the roster export.
+     * Pattern: {SanitizedGroupName}_Roster.{extension}
+     * @param {string} groupName
+     * @param {ExportFormat} format
+     * @return {string}
+     * @memberof RosterExportService
+     */
+    buildFilename(groupName, format) {
+        const sanitized = this.sanitizeGroupName(groupName);
+        const extension = format === ExportFormat.CSV ? 'csv' : 'xlsx';
+        return `${sanitized}_Roster.${extension}`;
+    }
+    /**
+     * Sanitizes the group name for use in a filename.
+     * Replaces non-alphanumeric characters (except hyphen/underscore) with underscore,
+     * collapses consecutive underscores, and truncates to 200 chars.
+     * @param {string} groupName
+     * @return {string}
+     * @memberof RosterExportService
+     */
+    sanitizeGroupName(groupName) {
+        if (!groupName) {
+            return 'Unnamed_Group';
+        }
+        const sanitized = groupName
+            .replace(/[^a-zA-Z0-9_-]/g, '_')
+            .replace(/_+/g, '_')
+            .substring(0, 200);
+        return sanitized || 'Unnamed_Group';
+    }
+    /**
+     * Writes the downloaded bytes to disk and resolves ONLY when the save has actually
+     * completed.
+     *
+     * The Save picker is opened earlier (at policy-confirm time, while user activation
+     * is still valid — see {@link startExport}); this method only writes to the handle
+     * it produced. That keeps the "success dialog after save" ordering without hitting
+     * the SecurityError that occurs when the picker is opened from this async callback.
+     *
+     * When no handle is provided (File System Access API unavailable, or the picker
+     * errored), we fall back to FileSaver's `saveAs()`, which resolves immediately.
+     * @param {Blob} blob - The file contents
+     * @param {string} filename - The suggested filename (used by the saveAs fallback)
+     * @param {ExportFormat} format - The selected export format (drives MIME type)
+     * @param {FileSystemFileHandle | null} fileHandle - Handle from the Save picker, or null
+     * @return {Promise<{ saved: boolean }>} Resolves with `saved: true` once written.
+     * @memberof RosterExportService
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async downloadFile(blob, filename, format, fileHandle) {
+        const mimeType = format === ExportFormat.CSV
+            ? 'text/csv'
+            : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        const typedBlob = new Blob([blob], { type: mimeType });
+        // No handle (API unavailable or picker errored) → standard download.
+        if (!fileHandle) {
+            saveAs(typedBlob, filename);
+            return { saved: true };
+        }
+        // Write to the location the user already chose at confirm time.
+        const writable = await fileHandle.createWritable();
+        await writable.write(typedBlob);
+        await writable.close();
+        return { saved: true };
+    }
+    /**
+     * Cleanup — call from the component's ngOnDestroy.
+     * @memberof RosterExportService
+     */
+    destroy() {
+        this.destroy$.next(true);
+        // This service is providedIn: 'root' (singleton), so its state survives
+        // navigation. Reset the UI-facing flags so a new roster component instance
+        // does not inherit a stale-open popover or a permanently-disabled export
+        // button if the user left the page mid-export or with the popover open.
+        this.isPopoverOpenSubject$.next(false);
+        this.isExportInProgressSubject$.next(false);
+        // Signal current takeUntil subscriptions to unsubscribe, then re-create the
+        // subject. This service is a providedIn: 'root' singleton whose destroy() is
+        // called on every ViewRosterComponent teardown; completing destroy$ would
+        // permanently close it, so later exports could never be torn down. A fresh
+        // subject keeps the teardown channel usable across component lifecycles.
+        this.destroy$.next(true);
+        this.destroy$ = new Subject();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RosterExportService, deps: [{ token: i1.HttpClient }, { token: i2.MatDialog }, { token: i3.AlertsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RosterExportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RosterExportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.MatDialog }, { type: i3.AlertsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roster-export.service.js","sourceRoot":"","sources":["../../../../../projects/groups/src/lib/services/roster-export.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,UAAU,EAAgB,MAAM,sBAAsB,CAAC;AAE5E,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,OAAO,EACL,YAAY,EAEZ,iCAAiC,EAEjC,4BAA4B,GAE7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,KAAK,WAAW,MAAM,0BAA0B,CAAC;;;;;AAExD;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,OAAO,mBAAmB;IAqC9B;IACE,0CAA0C;IAClC,UAAsB;IAC9B,0CAA0C;IAClC,MAAiB;IACzB,0CAA0C;IAClC,YAA2B;QAJ3B,eAAU,GAAV,UAAU,CAAY;QAEtB,WAAM,GAAN,MAAM,CAAW;QAEjB,iBAAY,GAAZ,YAAY,CAAe;QA1CrC,8DAA8D;QACtD,cAAS,GAAQ,WAAW,CAAC;QAE7B,aAAQ,GAAG,IAAI,OAAO,EAAW,CAAC;QAE1C,wCAAwC;QAChC,0BAAqB,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QACpE,mBAAc,GAAG,IAAI,CAAC,qBAAqB,CAAC,YAAY,EAAE,CAAC;QAE3D,oDAAoD;QAC5C,+BAA0B,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QACzE,wBAAmB,GAAG,IAAI,CAAC,0BAA0B,CAAC,YAAY,EAAE,CAAC;QAErE,4CAA4C;QAC5C,wBAAmB,GAAyB;YAC1C;gBACE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,IAAI,KAAK;gBACvE,KAAK,EAAE,YAAY,CAAC,GAAG;gBACvB,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,EAAE,SAAS,IAAI,sBAAsB;aACjG;YACD;gBACE,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,IAAI,OAAO;gBAC3E,KAAK,EAAE,YAAY,CAAC,KAAK;gBACzB,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,IAAI,wBAAwB;aACrG;SACF,CAAC;QAEF,qDAAqD;QACrD,0BAAqB,GAA2B;YAC9C,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,IAAI,sBAAsB;YACzF,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,KAAK,EAAE,QAAQ,IAAI,kBAAkB;SACxF,CAAC;QAEF,oBAAoB;QACpB,iBAAY,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,IAAI,2CAA2C,CAAC;IAStG,CAAC;IAEJ;;;;OAIG;IACH,aAAa,CAAC,GAAW;QACvB,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED;;;OAGG;IACH,YAAY;QACV,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;OAQG;IACH,gBAAgB,CAAC,MAAoB,EAAE,OAAe,EAAE,SAAiB;QACvE,IAAI,CAAC,YAAY,EAAE,CAAC;QAEpB,MAAM,UAAU,GAAiC;YAC/C,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,IAAI,iCAAiC;YAC7F,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,IAAI,gOAAgO;YAClS,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,IAAI,2DAA2D;YAC/H,cAAc,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,IAAI,4BAA4B;YAC1G,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,IAAI,QAAQ;YAChF,YAAY,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,IAAI,SAAS;SACpF,CAAC;QAEF,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iCAAiC,EAAE;YACpE,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,OAAO;YACd,UAAU,EAAE,CAAC,sBAAsB,CAAC;SACrC,CAAC,CAAC;QAEH,SAAS,CAAC,WAAW,EAAE;aACpB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC9B,SAAS,CAAC,CAAC,SAAkB,EAAE,EAAE;YAChC,IAAI,SAAS,EAAE;gBACb,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;aAC9C;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACK,WAAW,CAAC,MAAoB,EAAE,OAAe,EAAE,SAAiB;QAC1E,8DAA8D;QAC9D,MAAM,kBAAkB,GAAI,MAAc,CAAC,kBAAkB,CAAC;QAE9D,IAAI,OAAO,kBAAkB,KAAK,UAAU,EAAE;YAC5C,8EAA8E;YAC9E,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;YACrD,OAAO;SACR;QAED,MAAM,QAAQ,GAAG,MAAM,KAAK,YAAY,CAAC,GAAG;YAC1C,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,mEAAmE,CAAC;QACxE,MAAM,SAAS,GAAG,MAAM,KAAK,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;QACjE,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAE5D,0EAA0E;QAC1E,kBAAkB,CAAC;YACjB,aAAa;YACb,KAAK,EAAE;gBACL;oBACE,WAAW,EAAE,MAAM,KAAK,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY;oBACpE,MAAM,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE;iBACpC;aACF;SACF,CAAC;YACA,8DAA8D;aAC7D,IAAI,CAAC,CAAC,MAAW,EAAE,EAAE;YACpB,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACzD,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;YACxB,oEAAoE;YACpE,IAAI,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE;gBAChE,OAAO;aACR;YACD,0DAA0D;YAC1D,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;OAWG;IACH,8DAA8D;IACtD,aAAa,CAAC,MAAoB,EAAE,OAAe,EAAE,SAAiB,EAAE,UAAe;QAC7F,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE3C,wEAAwE;QACxE,yEAAyE;QACzE,wBAAwB;QACxB,MAAM,WAAW,GAAG,MAAM,KAAK,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QACjE,MAAM,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC3D,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,eAAe,EAAE,yBAAyB,OAAO,EAAE,CAAC;QAExE,IAAI,CAAC,UAAU;aACZ,GAAG,CAAC,GAAG,EAAE;YACR,MAAM;YACN,YAAY,EAAE,MAAM;YACpB,OAAO,EAAE,UAAU;SACpB,CAAC;aACD,IAAI,CACH,GAAG,CAAC,CAAC,QAA4B,EAAE,EAAE;YACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAC/E,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAY,EAAE,QAAQ,EAAE,CAAC;QACnD,CAAC,CAAC,EACF,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5C,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;gBAC5B,MAAM,EAAE,QAAQ;gBAChB,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,IAAI,4CAA4C;gBAC7G,SAAS,EAAE,SAAS,CAAC,KAAK;gBAC1B,aAAa,EAAE,IAAI;aACpB,CAAC,CAAC;YACH,uEAAuE;YACvE,kEAAkE;YAClE,wBAAwB;YACxB,OAAO,KAAK,CAAC;QACf,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CACzB;aACA,SAAS,CAAC;YACT,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE;gBACf,2EAA2E;gBAC3E,yEAAyE;gBACzE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC;qBAChE,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;oBAClB,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC5C,IAAI,KAAK,EAAE;wBACT,IAAI,CAAC,oCAAoC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;qBAC5D;gBACH,CAAC,CAAC;qBACD,KAAK,CAAC,GAAG,EAAE;oBACV,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC5C,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;wBAC5B,MAAM,EAAE,QAAQ;wBAChB,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,IAAI,4CAA4C;wBAC7G,SAAS,EAAE,SAAS,CAAC,KAAK;wBAC1B,aAAa,EAAE,IAAI;qBACpB,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACP,CAAC;SACF,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACK,oCAAoC,CAAC,QAAgB;QAC3D,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,IAAI,uCAAuC,CAAC;QACvH,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,IAAI,OAAO,CAAC;QAEvF,MAAM,UAAU,GAA4B;YAC1C,OAAO,EAAE,cAAc;YACvB,QAAQ;YACR,UAAU;SACX,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE;YAC7C,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,OAAO;YACd,UAAU,EAAE,CAAC,oCAAoC,CAAC;YAClD,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACK,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;SACnG;QACD,gFAAgF;QAChF,gFAAgF;QAChF,6EAA6E;QAC7E,kFAAkF;QAClF,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;OAQG;IACK,2BAA2B,CAAC,QAA4B,EAAE,MAAoB,EAAE,SAAiB;QACvG,MAAM,kBAAkB,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QACvE,IAAI,kBAAkB,EAAE;YACtB,MAAM,aAAa,GAAG,kBAAkB,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;YACvE,IAAI,aAAa,IAAI,aAAa,CAAC,CAAC,CAAC,EAAE;gBACrC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;aACzE;SACF;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;OAOG;IACH,aAAa,CAAC,SAAiB,EAAE,MAAoB;QACnD,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACpD,MAAM,SAAS,GAAG,MAAM,KAAK,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QAC/D,OAAO,GAAG,SAAS,WAAW,SAAS,EAAE,CAAC;IAC5C,CAAC;IAED;;;;;;;OAOG;IACH,iBAAiB,CAAC,SAAiB;QACjC,IAAI,CAAC,SAAS,EAAE;YACd,OAAO,eAAe,CAAC;SACxB;QACD,MAAM,SAAS,GAAG,SAAS;aACxB,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC;aAC/B,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;aACnB,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAErB,OAAO,SAAS,IAAI,eAAe,CAAC;IACtC,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,8DAA8D;IAC9D,KAAK,CAAC,YAAY,CAAC,IAAU,EAAE,QAAgB,EAAE,MAAoB,EAAE,UAAe;QACpF,MAAM,QAAQ,GAAG,MAAM,KAAK,YAAY,CAAC,GAAG;YAC1C,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,mEAAmE,CAAC;QACxE,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEvD,qEAAqE;QACrE,IAAI,CAAC,UAAU,EAAE;YACf,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC5B,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;SACxB;QAED,gEAAgE;QAChE,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,cAAc,EAAE,CAAC;QACnD,MAAM,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChC,MAAM,QAAQ,CAAC,KAAK,EAAE,CAAC;QACvB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,OAAO;QACL,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,wEAAwE;QACxE,2EAA2E;QAC3E,yEAAyE;QACzE,wEAAwE;QACxE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5C,4EAA4E;QAC5E,6EAA6E;QAC7E,0EAA0E;QAC1E,2EAA2E;QAC3E,yEAAyE;QACzE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,IAAI,OAAO,EAAW,CAAC;IACzC,CAAC;+GAtYU,mBAAmB;mHAAnB,mBAAmB,cAFlB,MAAM;;4FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpResponse } from '@angular/common/http';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { BehaviorSubject, EMPTY, Subject, takeUntil } from 'rxjs';\r\nimport { map, catchError } from 'rxjs/operators';\r\nimport { saveAs } from 'file-saver';\r\nimport {\r\n  ExportFormat,\r\n  ExportFormatOption,\r\n  PolicyConfirmationDialogComponent,\r\n  PolicyConfirmationDialogData,\r\n  ExportSuccessDialogComponent,\r\n  ExportSuccessDialogData,\r\n} from '@ieeesa-npm/presentation';\r\nimport { AlertType } from '@ieeesa-npm/models';\r\nimport { AlertsService } from '@ieeesa-npm/utility';\r\nimport * as screenTexts from '../assets/constants.json';\r\n\r\n/**\r\n * RosterExportService owns the complete group roster export flow:\r\n * 1. Manages export popover open/close state\r\n * 2. Opens IEEE Data Access and Use Policy confirmation dialog\r\n * 3. Calls the backend roster export API (blob response)\r\n * 4. Triggers file download via File System Access API / file-saver\r\n * 5. Shows success/error dialogs and toasts\r\n *\r\n * The component only needs to:\r\n * - Subscribe to `isPopoverOpen$` for popover visibility\r\n * - Call `togglePopover()` on Export button click\r\n * - Call `onFormatSelected(format, groupId, groupName)` when user picks a format\r\n *\r\n * Follows the same pattern as MeetingExportService in the events-and-meetings library.\r\n * @export\r\n * @class RosterExportService\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RosterExportService {\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  private constants: any = screenTexts;\r\n  private apiBaseUrl!: string;\r\n  private destroy$ = new Subject<boolean>();\r\n\r\n  /** Controls popover open/close state */\r\n  private isPopoverOpenSubject$ = new BehaviorSubject<boolean>(false);\r\n  isPopoverOpen$ = this.isPopoverOpenSubject$.asObservable();\r\n\r\n  /** Controls in-progress state for button disable */\r\n  private isExportInProgressSubject$ = new BehaviorSubject<boolean>(false);\r\n  isExportInProgress$ = this.isExportInProgressSubject$.asObservable();\r\n\r\n  /** Format options for the export popover */\r\n  exportFormatOptions: ExportFormatOption[] = [\r\n    {\r\n      label: this.constants?.rosterExport?.formatOptions?.csv?.label ?? 'CSV',\r\n      value: ExportFormat.CSV,\r\n      ariaLabel: this.constants?.rosterExport?.formatOptions?.csv?.ariaLabel ?? 'Export roster as CSV',\r\n    },\r\n    {\r\n      label: this.constants?.rosterExport?.formatOptions?.excel?.label ?? 'Excel',\r\n      value: ExportFormat.EXCEL,\r\n      ariaLabel: this.constants?.rosterExport?.formatOptions?.excel?.ariaLabel ?? 'Export roster as Excel',\r\n    },\r\n  ];\r\n\r\n  /** Subtitle labels for the format selection cards */\r\n  exportFormatSubtitles: Record<string, string> = {\r\n    csv: this.constants?.rosterExport?.formatOptions?.csv?.subtitle ?? 'Comma separated file',\r\n    xls: this.constants?.rosterExport?.formatOptions?.excel?.subtitle ?? 'Spreadsheet File',\r\n  };\r\n\r\n  /** Popover title */\r\n  popoverTitle = this.constants?.rosterExport?.popoverTitle ?? 'Select the file format for roster export.';\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private httpClient: HttpClient,\r\n    // eslint-disable-next-line no-unused-vars\r\n    private dialog: MatDialog,\r\n    // eslint-disable-next-line no-unused-vars\r\n    private alertService: AlertsService\r\n  ) {}\r\n\r\n  /**\r\n   * Sets the API base URL for roster export calls.\r\n   * @param {string} url - Base URL (e.g., 'https://saappsapidev.ieee.org/v1')\r\n   * @memberof RosterExportService\r\n   */\r\n  setApiBaseUrl(url: string): void {\r\n    this.apiBaseUrl = url;\r\n  }\r\n\r\n  /**\r\n   * Toggles the export format popover open/closed.\r\n   * Called by the component on Export button click.\r\n   * @memberof RosterExportService\r\n   */\r\n  togglePopover(): void {\r\n    this.isPopoverOpenSubject$.next(!this.isPopoverOpenSubject$.getValue());\r\n  }\r\n\r\n  /**\r\n   * Closes the export format popover.\r\n   * @memberof RosterExportService\r\n   */\r\n  closePopover(): void {\r\n    this.isPopoverOpenSubject$.next(false);\r\n  }\r\n\r\n  /**\r\n   * Handles format selection from the export popover.\r\n   * Closes popover, opens IEEE Policy dialog, on confirm triggers export.\r\n   * This is the main entry point called by the component after user picks a format.\r\n   * @param {ExportFormat} format - Selected format (CSV or XLS)\r\n   * @param {string} groupId - The group ID to export the roster for\r\n   * @param {string} groupName - The group name for filename generation\r\n   * @memberof RosterExportService\r\n   */\r\n  onFormatSelected(format: ExportFormat, groupId: string, groupName: string): void {\r\n    this.closePopover();\r\n\r\n    const dialogData: PolicyConfirmationDialogData = {\r\n      title: this.constants?.rosterExport?.policyDialog?.title ?? 'IEEE Data Access and Use Policy',\r\n      bodyText: this.constants?.rosterExport?.policyDialog?.bodyText ?? 'The application is governed by IEEE\\'s data access and use policy. Data can only be used for its original intended purpose. Click \"Confirm\" to export the data into a CSV/Excel file or click \"Cancel\" to cancel the download.',\r\n      policyUrl: this.constants?.rosterExport?.policyDialog?.policyUrl ?? 'https://www.ieee.org/ieee-data-access-and-use-policy.html',\r\n      policyLinkText: this.constants?.rosterExport?.policyDialog?.policyLinkText ?? 'data access and use policy',\r\n      cancelLabel: this.constants?.rosterExport?.policyDialog?.cancelLabel ?? 'Cancel',\r\n      confirmLabel: this.constants?.rosterExport?.policyDialog?.confirmLabel ?? 'Confirm',\r\n    };\r\n\r\n    const dialogRef = this.dialog.open(PolicyConfirmationDialogComponent, {\r\n      data: dialogData,\r\n      width: '637px',\r\n      panelClass: ['ieeesa-policy-dialog'],\r\n    });\r\n\r\n    dialogRef.afterClosed()\r\n      .pipe(takeUntil(this.destroy$))\r\n      .subscribe((confirmed: boolean) => {\r\n        if (confirmed) {\r\n          this.startExport(format, groupId, groupName);\r\n        }\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Starts the export after the user confirms the policy dialog.\r\n   *\r\n   * When the File System Access API is available, the native Save picker is opened\r\n   * HERE — synchronously within the confirm handler — while the user activation from\r\n   * the confirm click is still valid. (Opening it later, inside the async HTTP\r\n   * response callback, would exceed the activation window and the browser would\r\n   * reject it with a SecurityError.) The obtained file handle is then passed to the\r\n   * HTTP flow, which writes the downloaded bytes to it once the response arrives, so\r\n   * the success dialog is still shown only AFTER the file is saved.\r\n   *\r\n   * If the user cancels the picker we abort before making the request. If the API is\r\n   * unavailable (Firefox/Safari) we proceed without a handle and fall back to\r\n   * `saveAs()` after the response.\r\n   * @param {ExportFormat} format\r\n   * @param {string} groupId\r\n   * @param {string} groupName\r\n   * @memberof RosterExportService\r\n   */\r\n  private startExport(format: ExportFormat, groupId: string, groupName: string): void {\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    const showSaveFilePicker = (window as any).showSaveFilePicker;\r\n\r\n    if (typeof showSaveFilePicker !== 'function') {\r\n      // API unavailable: no handle; executeExport() will use the saveAs() fallback.\r\n      this.executeExport(format, groupId, groupName, null);\r\n      return;\r\n    }\r\n\r\n    const mimeType = format === ExportFormat.CSV\r\n      ? 'text/csv'\r\n      : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';\r\n    const extension = format === ExportFormat.CSV ? '.csv' : '.xlsx';\r\n    const suggestedName = this.buildFilename(groupName, format);\r\n\r\n    // Open the picker now, while the confirm-click activation is still valid.\r\n    showSaveFilePicker({\r\n      suggestedName,\r\n      types: [\r\n        {\r\n          description: format === ExportFormat.CSV ? 'CSV File' : 'Excel File',\r\n          accept: { [mimeType]: [extension] },\r\n        },\r\n      ],\r\n    })\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      .then((handle: any) => {\r\n        this.executeExport(format, groupId, groupName, handle);\r\n      })\r\n      .catch((error: unknown) => {\r\n        // User cancelled the Save dialog — abort silently, no request made.\r\n        if (error instanceof DOMException && error.name === 'AbortError') {\r\n          return;\r\n        }\r\n        // Any other picker error: fall back to the saveAs() flow.\r\n        this.executeExport(format, groupId, groupName, null);\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Executes the roster export API call and writes the downloaded file.\r\n   * Endpoint: GET /v1/groups/roster/export/{groupId}?format=csv|xlsx\r\n   * When a pre-obtained file handle is provided (from the picker opened at confirm\r\n   * time) the bytes are written to it; otherwise it falls back to `saveAs()`.\r\n   * The success dialog is shown only after the file has been written.\r\n   * @param {ExportFormat} format - The selected export format\r\n   * @param {string} groupId - The group identifier\r\n   * @param {string} groupName - The group name for filename\r\n   * @param {FileSystemFileHandle | null} fileHandle - Handle from the Save picker, or null\r\n   * @memberof RosterExportService\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  private executeExport(format: ExportFormat, groupId: string, groupName: string, fileHandle: any): void {\r\n    this.isExportInProgressSubject$.next(true);\r\n\r\n    // Backend expects 'csv' or 'xlsx'. The ExportFormat.EXCEL enum value is\r\n    // 'xls', so it must be mapped to 'xlsx' here — sending 'xls' is rejected\r\n    // with error code 1079.\r\n    const formatValue = format === ExportFormat.CSV ? 'csv' : 'xlsx';\r\n    const params = new HttpParams().set('format', formatValue);\r\n    const url = `${this.getExportApiUrl()}/groups/roster/export/${groupId}`;\r\n\r\n    this.httpClient\r\n      .get(url, {\r\n        params,\r\n        responseType: 'blob',\r\n        observe: 'response',\r\n      })\r\n      .pipe(\r\n        map((response: HttpResponse<Blob>) => {\r\n          const filename = this.extractFilenameFromResponse(response, format, groupName);\r\n          return { blob: response.body as Blob, filename };\r\n        }),\r\n        catchError(() => {\r\n          this.isExportInProgressSubject$.next(false);\r\n          this.alertService.showMessage({\r\n            status: 'custom',\r\n            message: this.constants?.rosterExport?.messages?.exportFailed ?? 'Failed to export roster. Please try again.',\r\n            alertType: AlertType.ERROR,\r\n            isCloseNeeded: true,\r\n          });\r\n          // Error is fully handled (alert shown). Complete the stream instead of\r\n          // rethrowing, so the next-only subscribe does not report it as an\r\n          // unhandled RxJS error.\r\n          return EMPTY;\r\n        }),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe({\r\n        next: (result) => {\r\n          // Write to the pre-obtained handle (picker opened at confirm time) or fall\r\n          // back to saveAs(). Success dialog only shows after the file is written.\r\n          this.downloadFile(result.blob, result.filename, format, fileHandle)\r\n            .then(({ saved }) => {\r\n              this.isExportInProgressSubject$.next(false);\r\n              if (saved) {\r\n                this.showExportSuccessDialogAfterDownload(result.filename);\r\n              }\r\n            })\r\n            .catch(() => {\r\n              this.isExportInProgressSubject$.next(false);\r\n              this.alertService.showMessage({\r\n                status: 'custom',\r\n                message: this.constants?.rosterExport?.messages?.exportFailed ?? 'Failed to export roster. Please try again.',\r\n                alertType: AlertType.ERROR,\r\n                isCloseNeeded: true,\r\n              });\r\n            });\r\n        },\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Shows the export success dialog after a successful file download.\r\n   * @param {string} filename - The downloaded filename\r\n   * @memberof RosterExportService\r\n   */\r\n  private showExportSuccessDialogAfterDownload(filename: string): void {\r\n    const successMessage = this.constants?.rosterExport?.successDialog?.message ?? 'The file was downloaded successfully.';\r\n    const closeLabel = this.constants?.rosterExport?.successDialog?.closeButton ?? 'Close';\r\n\r\n    const dialogData: ExportSuccessDialogData = {\r\n      message: successMessage,\r\n      filename,\r\n      closeLabel,\r\n    };\r\n\r\n    this.dialog.open(ExportSuccessDialogComponent, {\r\n      data: dialogData,\r\n      width: '467px',\r\n      panelClass: ['ieeesa-export-success-dialog-panel'],\r\n      autoFocus: false,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Returns the API base URL for roster export.\r\n   * @return {string}\r\n   * @memberof RosterExportService\r\n   */\r\n  private getExportApiUrl(): string {\r\n    if (!this.apiBaseUrl) {\r\n      throw new Error('RosterExportService apiBaseUrl is not set. Call setApiBaseUrl() before export.');\r\n    }\r\n    // apiBaseUrl already carries the version segment (e.g. '.../v1'), same as every\r\n    // other GroupsService call which is built as `${apiBaseUrl}/groups/...`. So the\r\n    // caller only appends '/groups/roster/export/{groupId}' — the version is NOT\r\n    // repeated here. Strip a trailing slash to avoid a double slash before '/groups'.\r\n    return this.apiBaseUrl.replace(/\\/+$/, '');\r\n  }\r\n\r\n  /**\r\n   * Extracts filename from Content-Disposition header.\r\n   * Falls back to buildFilename() if header is missing.\r\n   * @param {HttpResponse<Blob>} response\r\n   * @param {ExportFormat} format\r\n   * @param {string} groupName\r\n   * @return {string}\r\n   * @memberof RosterExportService\r\n   */\r\n  private extractFilenameFromResponse(response: HttpResponse<Blob>, format: ExportFormat, groupName: string): string {\r\n    const contentDisposition = response.headers.get('Content-Disposition');\r\n    if (contentDisposition) {\r\n      const filenameMatch = contentDisposition.match(/filename=\"?([^\"]+)\"?/);\r\n      if (filenameMatch && filenameMatch[1]) {\r\n        return filenameMatch[1].replace(/[/\\\\:*?\"<>|]/g, '_').substring(0, 200);\r\n      }\r\n    }\r\n    return this.buildFilename(groupName, format);\r\n  }\r\n\r\n  /**\r\n   * Builds a sanitized filename for the roster export.\r\n   * Pattern: {SanitizedGroupName}_Roster.{extension}\r\n   * @param {string} groupName\r\n   * @param {ExportFormat} format\r\n   * @return {string}\r\n   * @memberof RosterExportService\r\n   */\r\n  buildFilename(groupName: string, format: ExportFormat): string {\r\n    const sanitized = this.sanitizeGroupName(groupName);\r\n    const extension = format === ExportFormat.CSV ? 'csv' : 'xlsx';\r\n    return `${sanitized}_Roster.${extension}`;\r\n  }\r\n\r\n  /**\r\n   * Sanitizes the group name for use in a filename.\r\n   * Replaces non-alphanumeric characters (except hyphen/underscore) with underscore,\r\n   * collapses consecutive underscores, and truncates to 200 chars.\r\n   * @param {string} groupName\r\n   * @return {string}\r\n   * @memberof RosterExportService\r\n   */\r\n  sanitizeGroupName(groupName: string): string {\r\n    if (!groupName) {\r\n      return 'Unnamed_Group';\r\n    }\r\n    const sanitized = groupName\r\n      .replace(/[^a-zA-Z0-9_-]/g, '_')\r\n      .replace(/_+/g, '_')\r\n      .substring(0, 200);\r\n\r\n    return sanitized || 'Unnamed_Group';\r\n  }\r\n\r\n  /**\r\n   * Writes the downloaded bytes to disk and resolves ONLY when the save has actually\r\n   * completed.\r\n   *\r\n   * The Save picker is opened earlier (at policy-confirm time, while user activation\r\n   * is still valid — see {@link startExport}); this method only writes to the handle\r\n   * it produced. That keeps the \"success dialog after save\" ordering without hitting\r\n   * the SecurityError that occurs when the picker is opened from this async callback.\r\n   *\r\n   * When no handle is provided (File System Access API unavailable, or the picker\r\n   * errored), we fall back to FileSaver's `saveAs()`, which resolves immediately.\r\n   * @param {Blob} blob - The file contents\r\n   * @param {string} filename - The suggested filename (used by the saveAs fallback)\r\n   * @param {ExportFormat} format - The selected export format (drives MIME type)\r\n   * @param {FileSystemFileHandle | null} fileHandle - Handle from the Save picker, or null\r\n   * @return {Promise<{ saved: boolean }>} Resolves with `saved: true` once written.\r\n   * @memberof RosterExportService\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  async downloadFile(blob: Blob, filename: string, format: ExportFormat, fileHandle: any): Promise<{ saved: boolean }> {\r\n    const mimeType = format === ExportFormat.CSV\r\n      ? 'text/csv'\r\n      : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';\r\n    const typedBlob = new Blob([blob], { type: mimeType });\r\n\r\n    // No handle (API unavailable or picker errored) → standard download.\r\n    if (!fileHandle) {\r\n      saveAs(typedBlob, filename);\r\n      return { saved: true };\r\n    }\r\n\r\n    // Write to the location the user already chose at confirm time.\r\n    const writable = await fileHandle.createWritable();\r\n    await writable.write(typedBlob);\r\n    await writable.close();\r\n    return { saved: true };\r\n  }\r\n\r\n  /**\r\n   * Cleanup — call from the component's ngOnDestroy.\r\n   * @memberof RosterExportService\r\n   */\r\n  destroy(): void {\r\n    this.destroy$.next(true);\r\n    // This service is providedIn: 'root' (singleton), so its state survives\r\n    // navigation. Reset the UI-facing flags so a new roster component instance\r\n    // does not inherit a stale-open popover or a permanently-disabled export\r\n    // button if the user left the page mid-export or with the popover open.\r\n    this.isPopoverOpenSubject$.next(false);\r\n    this.isExportInProgressSubject$.next(false);\r\n    // Signal current takeUntil subscriptions to unsubscribe, then re-create the\r\n    // subject. This service is a providedIn: 'root' singleton whose destroy() is\r\n    // called on every ViewRosterComponent teardown; completing destroy$ would\r\n    // permanently close it, so later exports could never be torn down. A fresh\r\n    // subject keeps the teardown channel usable across component lifecycles.\r\n    this.destroy$.next(true);\r\n    this.destroy$ = new Subject<boolean>();\r\n  }\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -27,6 +27,7 @@ export * from './lib/models/table-column-schema-user-group.model';
 export * from './lib/models/parent-groups-info.model';
 export * from './lib/models/reciprocal-credit.model';
 export * from './lib/services/groups.service';
+export * from './lib/services/roster-export.service';
 export * from './lib/assets/form-validations';
 export * from './lib/groups.module';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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