@ieeesa-npm/groups 0.15.10 → 0.15.11

package/esm2022/lib/assets/constants.json

@@ -358,6 +358,16 @@
                 "Producer"
             ]
         ],
+        "tenantFieldLabels": {
+            "phone": "Phone Number",
+            "address": "Address",
+            "employer": "Employer"
+        },
+        "tenantFieldSampleValues": {
+            "phone": "+1 555 000 1234",
+            "address": "123 Main St, City, Country",
+            "employer": "Acme Corp"
+        },
         "uploadLabel": "Upload your file",
         "downloadSampleLabel": "Download Sample File",
         "sampleFileName": "Roster_Sample.csv",
@@ -383,6 +393,7 @@
             "singleFileOnly": "Please upload a single file at a time.",
             "noDataRecords": "No roster data found. The selected file contains headers but no roster records.",
             "missingHeaders": "Incorrect file format. Mandatory column headers are missing",
+            "forbidden": "You do not have permission to import a roster for this group.",
             "uploadFailed": "An error occurred while importing the roster. Please try again."
         },
         "errorLog": {
@@ -466,6 +477,7 @@
         "1037": "Group and parent group should not be same.",
         "1038": "Reassigning parent for this group is not allowed.",
         "1039": "You may not remove yourself from admin role.",
+        "1071": "You do not have permission to import a roster for this group.",
         "1072": "Incorrect file type. Only .xlsx and .csv files are supported.",
         "1073": "File size exceeds the maximum allowed size of 10MB.",
         "1074": "The file exceeds the maximum allowed limit of 10,000 rows.",

package/esm2022/lib/components/roster-import/roster-import.component.mjs

@@ -68,9 +68,76 @@ export class RosterImportComponent {
         /** Accepted file extensions (must match the BE contract: only .csv / .xlsx). */
         this.ACCEPTED_EXTENSIONS = ['.csv', '.xlsx'];
     }
-    /** Required column headers for display. */
+    /**
+     * Required column headers for display and the sample file. This is the static
+     * base set from constants PLUS any tenant-level required profile fields the
+     * host app configured (e.g. phone / address / employer), mapped to friendly
+     * headers and de-duplicated (case-insensitive) against the base columns.
+     * @return {string[]}
+     */
     get requiredColumns() {
-        return this.screenTexts?.requiredColumns ?? [];
+        const base = this.screenTexts?.requiredColumns ?? [];
+        return this.mergeTenantColumns(base);
+    }
+    /**
+     * Appends the tenant-configured columns (from {@link tenantExtraColumns}) to
+     * the base column headers.
+     * @param {string[]} base - The static base column headers.
+     * @return {string[]}
+     * @memberof RosterImportComponent
+     */
+    mergeTenantColumns(base) {
+        const extras = this.tenantExtraColumns(base);
+        return extras.length ? [...base, ...extras.map((c) => c.label)] : base;
+    }
+    /**
+     * Resolves the tenant-configured required profile fields into the EXTRA
+     * columns to append after the base set — the single source of truth shared by
+     * both the header list ({@link requiredColumns}) and the sample file
+     * ({@link downloadSampleFile}) so the two never drift out of alignment.
+     *
+     * Each field becomes one column with its friendly `label` (known keys use the
+     * label map; unknown keys fall back to a title-cased key) and a `sampleValue`
+     * for the sample row. Fields whose label already exists in the base set
+     * (case-insensitive) are skipped so a tenant field like "employer" that is
+     * already a base column is not duplicated.
+     * @param {string[]} base - The static base column headers.
+     * @return {{ label: string; sampleValue: string }[]}
+     * @memberof RosterImportComponent
+     */
+    tenantExtraColumns(base) {
+        const tenantFields = this.groupService?.getRequiredProfileFields() ?? [];
+        if (!tenantFields.length) {
+            return [];
+        }
+        const sampleMap = this.screenTexts?.tenantFieldSampleValues ?? {};
+        const seen = new Set(base.map((col) => col.toLowerCase()));
+        const extras = [];
+        tenantFields.forEach((field) => {
+            const label = this.tenantFieldLabel(field);
+            if (label && !seen.has(label.toLowerCase())) {
+                seen.add(label.toLowerCase());
+                extras.push({ label, sampleValue: sampleMap[field] ?? '' });
+            }
+        });
+        return extras;
+    }
+    /**
+     * Maps a tenant field key to its display header. Known keys use the configured
+     * label map; unknown keys fall back to a title-cased key.
+     * @param {string} field - The tenant field key (e.g. 'phone').
+     * @return {string}
+     * @memberof RosterImportComponent
+     */
+    tenantFieldLabel(field) {
+        const labels = this.screenTexts?.tenantFieldLabels ?? {};
+        if (labels[field]) {
+            return labels[field];
+        }
+        // Fallback: "phone_number" -> "Phone Number".
+        return field
+            .replace(/[_-]+/g, ' ')
+            .replace(/\b\w/g, (char) => char.toUpperCase());
     }
     /** Comma-separated accepted file types for the input element. */
     get acceptedFileTypes() {
@@ -256,6 +323,8 @@ export class RosterImportComponent {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     handleImportError(error) {
         this.importState = 'upload';
+        // BE error codes take priority when present (e.g. 1071 no permission, 1072
+        // format, 1073 too large, 1074 row limit, 1075 invalid status).
         const errorCodes = error?.error?.body?.errorCodes;
         if (Array.isArray(errorCodes) && errorCodes.length) {
             const code = errorCodes[0];
@@ -265,6 +334,16 @@ export class RosterImportComponent {
                     'An error occurred while importing the roster. Please try again.';
             return;
         }
+        // A 403 with no error-code body comes from the endpoint's @PreAuthorize
+        // (the user lacks Manage Group Member / Manage All Rosters for this group).
+        // Show the permission message — retrying will not help.
+        const status = error?.status ?? error?.error?.status;
+        if (status === 403) {
+            this.errorMessage =
+                this.screenTexts?.validation?.forbidden ??
+                    'You do not have permission to import a roster for this group.';
+            return;
+        }
         this.errorMessage =
             this.screenTexts?.validation?.uploadFailed ??
                 'An error occurred while importing the roster. Please try again.';
@@ -290,36 +369,43 @@ export class RosterImportComponent {
         }
     }
     /**
-     * Parses the BE `errorReport` raw JSON string into row-error view models.
+     * Normalizes the BE `error_report` into row-error view models.
      *
-     * The BE stores the report as a JSONB document wrapping the per-row entries:
-     * `{ "rows": [ { "row": 2, "field": "Email", "message": "..." } ] }`
-     * (serialized by its `ErrorReportWrapper`) and returns it verbatim via
-     * `@JsonRawValue`. So we read `parsed.rows`. A bare top-level array is also
-     * accepted as a fallback in case the contract is ever flattened.
-     * @param {(string | undefined)} errorReport - Raw JSON error report string.
+     * The BE wraps the per-row entries in a `{ rows: [ { row, field, message } ] }`
+     * document, but that value has been observed to arrive in MULTIPLE shapes:
+     *  - a parsed object `{ rows: [...] }` (confirm response — the common case),
+     *  - a raw JSON string of the same object (JSONB passthrough), or
+     *  - a bare array `[ { row, field, message } ]`.
+     * This handles all three (and `null`) so the error log renders regardless of
+     * how the field is serialized.
+     * @param {*} errorReport - The BE error_report (object, string, array, or null).
      * @return {RosterImportRowError[]}
      * @memberof RosterImportComponent
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parseErrorReport(errorReport) {
         if (!errorReport) {
             return [];
         }
-        try {
-            const parsed = JSON.parse(errorReport);
-            const entries = Array.isArray(parsed)
-                ? parsed
-                : parsed?.rows ?? [];
-            return entries.map((entry) => ({
-                rowNumber: entry?.row,
-                field: entry?.field,
-                errorMessage: entry?.message,
-            }));
-        }
-        catch {
-            // Malformed error report — surface no per-row errors rather than crash.
-            return [];
+        // If it's a string, parse it first; on parse failure, no row errors.
+        let value = errorReport;
+        if (typeof errorReport === 'string') {
+            try {
+                value = JSON.parse(errorReport);
+            }
+            catch {
+                return [];
+            }
         }
+        // Accept either a bare array or a { rows: [...] } wrapper object.
+        const entries = Array.isArray(value)
+            ? value
+            : (value?.rows ?? []);
+        return entries.map((entry) => ({
+            rowNumber: entry?.row,
+            field: entry?.field,
+            errorMessage: entry?.message,
+        }));
     }
     /**
      * Whether the result state should show the summary cards (added / skipped).
@@ -351,10 +437,16 @@ export class RosterImportComponent {
             .map((col) => this.toCsvCell(col))
             .join(',');
         // Sample data rows so the downloaded file shows the expected format, not
-        // just the column headers. Sourced from constants; each row is aligned to
-        // the required columns.
-        const sampleRows = this.screenTexts?.sampleRows ?? [];
-        const dataLines = sampleRows.map((row) => row.map((cell) => this.toCsvCell(cell)).join(','));
+        // just the column headers. The base row values come from constants; sample
+        // values for any tenant-configured columns are appended (from the SAME
+        // source that builds the headers) so every row lines up with the
+        // (base + tenant) header set.
+        const base = this.screenTexts?.requiredColumns ?? [];
+        const baseSampleRows = this.screenTexts?.sampleRows ?? [];
+        const tenantSampleCells = this.tenantExtraColumns(base).map((col) => col.sampleValue);
+        const dataLines = baseSampleRows.map((row) => [...row, ...tenantSampleCells]
+            .map((cell) => this.toCsvCell(cell))
+            .join(','));
         const csvContent = [headerLine, ...dataLines].join('\r\n') + '\r\n';
         const blob = new Blob([csvContent], {
             type: 'text/csv;charset=utf-8;',
@@ -440,4 +532,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             }], formCancel: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roster-import.component.js","sourceRoot":"","sources":["../../../../../../projects/groups/src/lib/components/roster-import/roster-import.component.ts","../../../../../../projects/groups/src/lib/components/roster-import/roster-import.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\nimport { Subject, switchMap, takeUntil } from 'rxjs';\r\nimport {\r\n  RosterImportErrorReport,\r\n  RosterImportJob,\r\n} from '../../models/roster-import.model';\r\nimport { RosterImportApiService } from '../../services/roster-import-api.service';\r\nimport { GroupsService } from '../../services/groups.service';\r\nimport * as constants from '../../assets/constants.json';\r\n\r\n/** States of the roster import flow. */\r\ntype RosterImportState = 'upload' | 'processing' | 'result';\r\n\r\n/**\r\n * View-model for the result screen. Populated from the confirmed\r\n * {@link RosterImportJob} returned by the backend.\r\n */\r\ninterface RosterImportResult {\r\n  totalRecords: number;\r\n  successCount: number;\r\n  failureCount: number;\r\n}\r\n\r\n/** Row error shown on the result screen (mapped from the BE error report). */\r\ninterface RosterImportRowError {\r\n  rowNumber: number;\r\n  field?: string;\r\n  errorMessage: string;\r\n}\r\n\r\n/**\r\n * Roster Import dialog.\r\n *\r\n * Lets an admin upload a CSV/XLSX roster file, shows a processing progress\r\n * bar, then a result summary (added / skipped) with per-row errors and an\r\n * error-log download.\r\n *\r\n * Wired to the real backend roster-import state machine\r\n * (sa-saapps-groups-api `RosterImportController`) via\r\n * {@link RosterImportApiService}: on Import it runs\r\n * upload → validate → confirm and renders the confirmed job's terminal counts\r\n * and per-row errors. Server-side validation errors (1072 unsupported format,\r\n * 1073 too large, 1074 row limit, 1075 invalid status) are surfaced inline.\r\n *\r\n * @export\r\n * @class RosterImportComponent\r\n */\r\n@Component({\r\n  selector: 'ieeesa-roster-import',\r\n  standalone: true,\r\n  imports: [CommonModule, MatButtonModule, MatProgressBarModule],\r\n  templateUrl: './roster-import.component.html',\r\n  styleUrls: ['./roster-import.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class RosterImportComponent implements OnInit, OnDestroy {\r\n  /** Carries the { groupId, groupName } payload from the opening dialog. */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  @Input() componentData: any;\r\n\r\n  /** Emitted after an import that added at least one row (parent refreshes). */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  @Output() submitFormResponse = new EventEmitter<any>();\r\n\r\n  /** Emitted when the user cancels/closes without a successful add. */\r\n  @Output() formCancel = new EventEmitter<void>();\r\n\r\n  destroy$ = new Subject<boolean>();\r\n\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  constants: any = constants;\r\n  screenTexts = this.constants?.rosterImport;\r\n\r\n  /** Current state of the import flow. */\r\n  importState: RosterImportState = 'upload';\r\n\r\n  /** The selected file. */\r\n  selectedFile: File | null = null;\r\n\r\n  /** File drag-over state. */\r\n  isDragOver = false;\r\n\r\n  /** Terminal upload result. */\r\n  uploadResult: RosterImportResult | null = null;\r\n\r\n  /** Row-level errors for the completed job. */\r\n  jobErrors: RosterImportRowError[] = [];\r\n\r\n  /** Inline validation / API error message. */\r\n  errorMessage: string | null = null;\r\n\r\n  /**\r\n   * Info banner shown when the file has headers but no data rows\r\n   * (Figma: \"No roster data found...\").\r\n   */\r\n  noDataMessage: string | null = null;\r\n\r\n  /** The import job id returned by upload (kept so cancel can clean it up). */\r\n  private importId: string | null = null;\r\n\r\n  /** Maximum file size in bytes (10 MB) — matches the BE 10MB limit. */\r\n  readonly MAX_FILE_SIZE = 10_485_760;\r\n\r\n  /** Accepted file extensions (must match the BE contract: only .csv / .xlsx). */\r\n  readonly ACCEPTED_EXTENSIONS = ['.csv', '.xlsx'];\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private rosterImportApiService: RosterImportApiService,\r\n    // eslint-disable-next-line no-unused-vars\r\n    private groupService: GroupsService\r\n  ) {}\r\n\r\n  /** Required column headers for display. */\r\n  get requiredColumns(): string[] {\r\n    return this.screenTexts?.requiredColumns ?? [];\r\n  }\r\n\r\n  /** Comma-separated accepted file types for the input element. */\r\n  get acceptedFileTypes(): string {\r\n    return this.ACCEPTED_EXTENSIONS.join(',');\r\n  }\r\n\r\n  /** The target group id from the dialog payload (falls back to selection). */\r\n  private get groupId(): string {\r\n    return (\r\n      this.componentData?.groupId ??\r\n      (this.groupService?.getSelectedGroupInfo()?.groupId as string) ??\r\n      ''\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Sets the API base URL on the import service.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  ngOnInit(): void {\r\n    this.rosterImportApiService.setApiBaseUrl(this.groupService?.apiBaseUrl);\r\n  }\r\n\r\n  /**\r\n   * Cleans up subscriptions when the component is destroyed.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next(true);\r\n    this.destroy$.complete();\r\n  }\r\n\r\n  /**\r\n   * Handles a file selected via the browse dialog.\r\n   * @param {Event} event - The change event from the hidden file input.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onFileSelected(event: Event): void {\r\n    const input = event.target as HTMLInputElement;\r\n    if (!input.files || input.files.length === 0) {\r\n      return;\r\n    }\r\n    if (input.files.length > 1) {\r\n      this.showSingleFileOnlyError();\r\n      return;\r\n    }\r\n    this.processFile(input.files[0]);\r\n  }\r\n\r\n  /**\r\n   * Handles a file dropped onto the dropzone.\r\n   * @param {DragEvent} event - The drop event.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onFileDrop(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    this.isDragOver = false;\r\n    const files = event.dataTransfer?.files;\r\n    if (!files || files.length === 0) {\r\n      return;\r\n    }\r\n    if (files.length > 1) {\r\n      this.showSingleFileOnlyError();\r\n      return;\r\n    }\r\n    this.processFile(files[0]);\r\n  }\r\n\r\n  /**\r\n   * Handles drag-over on the dropzone.\r\n   * @param {DragEvent} event - The dragover event.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onDragOver(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    this.isDragOver = true;\r\n  }\r\n\r\n  /**\r\n   * Handles drag-leave on the dropzone.\r\n   * @param {DragEvent} event - The dragleave event.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onDragLeave(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    this.isDragOver = false;\r\n  }\r\n\r\n  /**\r\n   * Validates the file type and size, then either sets it or shows an error.\r\n   * @param {File} file - The candidate file.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  processFile(file: File): void {\r\n    this.errorMessage = null;\r\n    this.noDataMessage = null;\r\n    this.uploadResult = null;\r\n    this.importId = null;\r\n    // Clear any previously selected (valid) file so an invalid new selection\r\n    // can't leave the Import button enabled for a stale file.\r\n    this.selectedFile = null;\r\n\r\n    const fileName = file.name.toLowerCase();\r\n    const isValidExtension = this.ACCEPTED_EXTENSIONS.some((ext) =>\r\n      fileName.endsWith(ext)\r\n    );\r\n    if (!isValidExtension) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.unsupportedType ??\r\n        'Incorrect file type. Please upload a valid .csv or .xlsx file.';\r\n      return;\r\n    }\r\n\r\n    if (file.size === 0) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.emptyFile ??\r\n        'The selected file is empty. Please upload a file with roster records.';\r\n      return;\r\n    }\r\n\r\n    if (file.size > this.MAX_FILE_SIZE) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.fileTooLarge ??\r\n        'File size exceeds the maximum allowed size of 10MB.';\r\n      return;\r\n    }\r\n\r\n    this.selectedFile = file;\r\n  }\r\n\r\n  /**\r\n   * Shows the single-file-only validation message.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  showSingleFileOnlyError(): void {\r\n    this.errorMessage =\r\n      this.screenTexts?.validation?.singleFileOnly ??\r\n      'Please upload a single file at a time.';\r\n  }\r\n\r\n  /**\r\n   * Removes the currently selected file and resets to the upload state.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onRemoveFile(): void {\r\n    this.selectedFile = null;\r\n    this.errorMessage = null;\r\n    this.noDataMessage = null;\r\n    this.uploadResult = null;\r\n    this.importId = null;\r\n    this.importState = 'upload';\r\n  }\r\n\r\n  /**\r\n   * Runs the real import: upload → validate → confirm. The progress bar is\r\n   * shown in indeterminate mode while the chain is in flight, then the\r\n   * confirmed job's terminal counts + per-row errors drive the result screen.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onImport(): void {\r\n    if (!this.selectedFile) {\r\n      return;\r\n    }\r\n    if (!this.groupId) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.uploadFailed ??\r\n        'An error occurred while importing the roster. Please try again.';\r\n      return;\r\n    }\r\n    this.errorMessage = null;\r\n    this.noDataMessage = null;\r\n    this.uploadResult = null;\r\n    this.jobErrors = [];\r\n    this.importId = null;\r\n    this.importState = 'processing';\r\n\r\n    this.rosterImportApiService\r\n      .uploadImportFile(this.selectedFile, this.groupId)\r\n      .pipe(\r\n        switchMap((job: RosterImportJob) => {\r\n          this.importId = job?.importId ?? null;\r\n          return this.rosterImportApiService.validateImportJob(\r\n            this.importId as string\r\n          );\r\n        }),\r\n        switchMap(() =>\r\n          this.rosterImportApiService.confirmImportJob(this.importId as string)\r\n        ),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe({\r\n        next: (confirmedJob: RosterImportJob) => {\r\n          this.finalizeResult(confirmedJob);\r\n        },\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        error: (error: any) => {\r\n          this.handleImportError(error);\r\n        },\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Maps a failed import call to an inline error message and returns the UI to\r\n   * the upload state so the user can retry. Known BE error codes (1072–1075)\r\n   * are mapped via constants; anything else uses the generic message.\r\n   * @param {*} error - The HttpErrorResponse.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  private handleImportError(error: any): void {\r\n    this.importState = 'upload';\r\n    const errorCodes: string[] | undefined = error?.error?.body?.errorCodes;\r\n    if (Array.isArray(errorCodes) && errorCodes.length) {\r\n      const code = errorCodes[0] as keyof typeof this.constants.errors;\r\n      this.errorMessage =\r\n        this.constants?.errors?.[code] ??\r\n        this.screenTexts?.validation?.uploadFailed ??\r\n        'An error occurred while importing the roster. Please try again.';\r\n      return;\r\n    }\r\n    this.errorMessage =\r\n      this.screenTexts?.validation?.uploadFailed ??\r\n      'An error occurred while importing the roster. Please try again.';\r\n  }\r\n\r\n  /**\r\n   * Stores the terminal result and moves to the result state. When the job had\r\n   * no data rows, shows the \"no roster data\" info banner instead of the summary\r\n   * cards.\r\n   * @param {RosterImportJob} job - The confirmed import job.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  finalizeResult(job: RosterImportJob): void {\r\n    const totalRecords = job?.totalRows ?? 0;\r\n    const successCount = job?.successRows ?? 0;\r\n    const failureCount = job?.failedRows ?? 0;\r\n\r\n    this.uploadResult = { totalRecords, successCount, failureCount };\r\n    this.jobErrors = this.parseErrorReport(job?.errorReport);\r\n    this.importState = 'result';\r\n\r\n    if (totalRecords === 0) {\r\n      this.noDataMessage =\r\n        this.screenTexts?.validation?.noDataRecords ??\r\n        'No roster data found. The selected file contains headers but no roster records.';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Parses the BE `errorReport` raw JSON string into row-error view models.\r\n   *\r\n   * The BE stores the report as a JSONB document wrapping the per-row entries:\r\n   * `{ \"rows\": [ { \"row\": 2, \"field\": \"Email\", \"message\": \"...\" } ] }`\r\n   * (serialized by its `ErrorReportWrapper`) and returns it verbatim via\r\n   * `@JsonRawValue`. So we read `parsed.rows`. A bare top-level array is also\r\n   * accepted as a fallback in case the contract is ever flattened.\r\n   * @param {(string | undefined)} errorReport - Raw JSON error report string.\r\n   * @return {RosterImportRowError[]}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  private parseErrorReport(errorReport?: string): RosterImportRowError[] {\r\n    if (!errorReport) {\r\n      return [];\r\n    }\r\n    try {\r\n      const parsed = JSON.parse(errorReport) as\r\n        | { rows?: RosterImportErrorReport[] }\r\n        | RosterImportErrorReport[];\r\n      const entries: RosterImportErrorReport[] = Array.isArray(parsed)\r\n        ? parsed\r\n        : parsed?.rows ?? [];\r\n      return entries.map((entry) => ({\r\n        rowNumber: entry?.row,\r\n        field: entry?.field,\r\n        errorMessage: entry?.message,\r\n      }));\r\n    } catch {\r\n      // Malformed error report — surface no per-row errors rather than crash.\r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Whether the result state should show the summary cards (added / skipped).\r\n   * Hidden for the \"no data records\" case.\r\n   * @return {boolean}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  get showSummaryCards(): boolean {\r\n    return !!this.uploadResult && this.uploadResult.totalRecords > 0;\r\n  }\r\n\r\n  /**\r\n   * Whether every processed row was skipped (drives the \"All Rows are skipped\"\r\n   * header on the errors card).\r\n   * @return {boolean}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  get allRowsSkipped(): boolean {\r\n    return (\r\n      !!this.uploadResult &&\r\n      this.uploadResult.totalRecords > 0 &&\r\n      this.uploadResult.successCount === 0\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Builds a client-side CSV sample file from the required columns and triggers\r\n   * a browser download. (Client-side generation until the template API exists.)\r\n   * @memberof RosterImportComponent\r\n   */\r\n  downloadSampleFile(): void {\r\n    const headerLine = this.requiredColumns\r\n      .map((col) => this.toCsvCell(col))\r\n      .join(',');\r\n\r\n    // Sample data rows so the downloaded file shows the expected format, not\r\n    // just the column headers. Sourced from constants; each row is aligned to\r\n    // the required columns.\r\n    const sampleRows: string[][] = this.screenTexts?.sampleRows ?? [];\r\n    const dataLines = sampleRows.map((row) =>\r\n      row.map((cell) => this.toCsvCell(cell)).join(',')\r\n    );\r\n\r\n    const csvContent = [headerLine, ...dataLines].join('\\r\\n') + '\\r\\n';\r\n    const blob = new Blob([csvContent], {\r\n      type: 'text/csv;charset=utf-8;',\r\n    });\r\n    const fileName = this.screenTexts?.sampleFileName ?? 'Roster_Sample.csv';\r\n    this.triggerDownload(blob, fileName);\r\n  }\r\n\r\n  /**\r\n   * Builds a CSV from the row-level errors and triggers a browser download so\r\n   * the user can correct and re-upload.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  downloadErrorLog(): void {\r\n    if (!this.jobErrors.length) {\r\n      return;\r\n    }\r\n    const headers: string[] = this.screenTexts?.errorLog?.headers ?? [\r\n      'Row',\r\n      'Field',\r\n      'Error',\r\n    ];\r\n    const rows = this.jobErrors.map((rowErr) =>\r\n      [rowErr.rowNumber, rowErr.field, rowErr.errorMessage]\r\n        .map((value) => this.toCsvCell(value))\r\n        .join(',')\r\n    );\r\n    const csvContent = [\r\n      headers.map((header) => this.toCsvCell(header)).join(','),\r\n      ...rows,\r\n    ].join('\\r\\n');\r\n    const fileName =\r\n      this.screenTexts?.errorLog?.fileName ?? 'Roster_Import_Error_Log.csv';\r\n    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\r\n    this.triggerDownload(blob, fileName);\r\n  }\r\n\r\n  /**\r\n   * Escapes a value for safe inclusion in a CSV cell.\r\n   * @param {(string | number | undefined | null)} value - The raw cell value.\r\n   * @return {string} - the CSV-safe cell string.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  toCsvCell(value: string | number | undefined | null): string {\r\n    const raw = value === undefined || value === null ? '' : String(value);\r\n    if (/[\",\\r\\n]/.test(raw)) {\r\n      return `\"${raw.replace(/\"/g, '\"\"')}\"`;\r\n    }\r\n    return raw;\r\n  }\r\n\r\n  /**\r\n   * Closes the dialog. Emits submitFormResponse when at least one row was added\r\n   * so the parent refreshes; otherwise emits formCancel.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onCancel(): void {\r\n    if (this.uploadResult && this.uploadResult.successCount > 0) {\r\n      this.submitFormResponse.emit(this.uploadResult);\r\n    } else {\r\n      this.formCancel.emit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Triggers a browser download for a generated blob.\r\n   * @param {Blob} blob - The file content.\r\n   * @param {string} fileName - The suggested filename.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  private triggerDownload(blob: Blob, fileName: string): void {\r\n    const url = URL.createObjectURL(blob);\r\n    const link = document.createElement('a');\r\n    link.href = url;\r\n    link.download = fileName;\r\n    link.click();\r\n    URL.revokeObjectURL(url);\r\n  }\r\n}\r\n","<div class=\"ieeesa-roster-import\">\r\n  <!-- Sub-heading band: \"Bulk Import Participants\" on the left, Import Roster\r\n       action on the right (appears once a file is selected) — matches the Figma.\r\n       The \"← Back to Rosters / Import Roster\" title row + X are rendered by the\r\n       shared ModalComponent above this. -->\r\n  <div class=\"ieeesa-roster-import__subheader\">\r\n    <span class=\"ieeesa-roster-import__subheader-title\">\r\n      {{ screenTexts?.subHeading ?? 'Bulk Import Participants' }}\r\n    </span>\r\n    <button\r\n      *ngIf=\"selectedFile\"\r\n      mat-button\r\n      type=\"button\"\r\n      class=\"mat-tertiary-button ieeesa-roster-import__import-btn\"\r\n      [disabled]=\"importState === 'processing'\"\r\n      (click)=\"onImport()\"\r\n      [attr.aria-label]=\"screenTexts?.buttons?.import ?? 'Import Roster'\"\r\n    >\r\n      <svg class=\"ieeesa-roster-import__import-btn-icon\" width=\"14\" height=\"14\" aria-hidden=\"true\">\r\n        <use xlink:href=\"assets/images/sprites/sprites.svg#icon-import\"></use>\r\n      </svg>\r\n      {{ screenTexts?.buttons?.import ?? 'Import Roster' }}\r\n    </button>\r\n  </div>\r\n\r\n  <!-- Required Columns Info -->\r\n  <div class=\"ieeesa-roster-import__columns-card\">\r\n    <div class=\"ieeesa-roster-import__columns-content\">\r\n      <p class=\"ieeesa-roster-import__columns-title\">\r\n        {{ screenTexts?.requiredColumnsTitle ?? 'Required columns' }}\r\n      </p>\r\n      <div class=\"ieeesa-roster-import__columns-chips\">\r\n        <span\r\n          *ngFor=\"let col of requiredColumns\"\r\n          class=\"ieeesa-roster-import__chip\"\r\n        >\r\n          {{ col }}\r\n        </span>\r\n      </div>\r\n    </div>\r\n    <div class=\"ieeesa-roster-import__sample-wrapper\">\r\n      <button\r\n        mat-button\r\n        class=\"mat-tertiary-button ieeesa-roster-import__download-btn\"\r\n        (click)=\"downloadSampleFile()\"\r\n        type=\"button\"\r\n        [attr.aria-label]=\"screenTexts?.ariaLabel?.downloadSample ?? 'Download Sample File'\"\r\n      >\r\n        <svg\r\n          class=\"ieeesa-roster-import__download-btn-icon\"\r\n          aria-hidden=\"true\"\r\n        >\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-file-doc\"></use>\r\n        </svg>\r\n        {{ screenTexts?.downloadSampleLabel ?? 'Download Sample File' }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n\r\n  <p class=\"ieeesa-roster-import__upload-label\">\r\n    {{ screenTexts?.uploadLabel ?? 'Upload your file' }}\r\n  </p>\r\n\r\n  <!-- Upload State -->\r\n  <ng-container *ngIf=\"importState === 'upload'\">\r\n    <!-- Hidden file input -->\r\n    <input\r\n      #fileInput\r\n      type=\"file\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      (change)=\"onFileSelected($event)\"\r\n      hidden\r\n      [attr.aria-label]=\"screenTexts?.uploadLabel ?? 'Upload your file'\"\r\n    />\r\n\r\n    <!-- Drag & Drop Zone -->\r\n    <div\r\n      class=\"ieeesa-roster-import__dropzone\"\r\n      [class.ieeesa-roster-import__dropzone--active]=\"isDragOver\"\r\n      (dragover)=\"onDragOver($event)\"\r\n      (dragleave)=\"onDragLeave($event)\"\r\n      (drop)=\"onFileDrop($event)\"\r\n      (click)=\"fileInput.click()\"\r\n      role=\"button\"\r\n      tabindex=\"0\"\r\n      (keydown.enter)=\"fileInput.click()\"\r\n      (keydown.space)=\"fileInput.click()\"\r\n      [attr.aria-label]=\"screenTexts?.ariaLabel?.dropzone ?? 'Drag and drop file upload area'\"\r\n    >\r\n      <ng-container *ngIf=\"!selectedFile\">\r\n        <svg class=\"ieeesa-roster-import__upload-icon\" width=\"22\" height=\"22\">\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-upload-gray\"></use>\r\n        </svg>\r\n        <p class=\"ieeesa-roster-import__dropzone-text\">\r\n          {{ screenTexts?.dropzoneText ?? 'Drag & drop a file here, or click to browse' }}\r\n        </p>\r\n        <p class=\"ieeesa-roster-import__dropzone-hint\">\r\n          {{ screenTexts?.dropzoneHint ?? 'Accepted formats: .csv, .xlsx' }}\r\n        </p>\r\n      </ng-container>\r\n      <ng-container *ngIf=\"selectedFile\">\r\n        <svg class=\"ieeesa-roster-import__upload-icon\" width=\"22\" height=\"22\">\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-upload-gray\"></use>\r\n        </svg>\r\n        <div class=\"ieeesa-roster-import__file-row\">\r\n          <p class=\"ieeesa-roster-import__file-name\">\r\n            <svg width=\"14\" height=\"14\">\r\n              <use xlink:href=\"assets/images/sprites/sprites.svg#icon-file-doc\"></use>\r\n            </svg>\r\n            {{ selectedFile.name }}\r\n          </p>\r\n          <button\r\n            mat-button\r\n            class=\"ieeesa-roster-import__remove-file-btn\"\r\n            (click)=\"onRemoveFile(); $event.stopPropagation()\"\r\n            type=\"button\"\r\n            [attr.aria-label]=\"screenTexts?.ariaLabel?.remove ?? 'Remove selected file'\"\r\n          >\r\n            &times;\r\n          </button>\r\n        </div>\r\n      </ng-container>\r\n    </div>\r\n\r\n    <!-- Inline Error Message -->\r\n    <div\r\n      *ngIf=\"errorMessage\"\r\n      class=\"ieeesa-roster-import__error-banner\"\r\n      role=\"alert\"\r\n    >\r\n      {{ errorMessage }}\r\n    </div>\r\n  </ng-container>\r\n\r\n  <!-- Processing / Result share the file display + progress bar -->\r\n  <ng-container *ngIf=\"importState === 'processing' || importState === 'result'\">\r\n    <div\r\n      class=\"ieeesa-roster-import__dropzone ieeesa-roster-import__dropzone--result\"\r\n    >\r\n      <svg class=\"ieeesa-roster-import__upload-icon\" width=\"22\" height=\"22\">\r\n        <use xlink:href=\"assets/images/sprites/sprites.svg#icon-upload-gray\"></use>\r\n      </svg>\r\n      <p class=\"ieeesa-roster-import__file-name\">\r\n        <svg width=\"14\" height=\"14\">\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-file-doc\"></use>\r\n        </svg>\r\n        {{ selectedFile?.name }}\r\n      </p>\r\n    </div>\r\n\r\n    <!-- Progress label (processing only) -->\r\n    <div\r\n      *ngIf=\"importState === 'processing'\"\r\n      class=\"ieeesa-roster-import__progress-head\"\r\n    >\r\n      <span class=\"ieeesa-roster-import__progress-label\">\r\n        {{ screenTexts?.processingLabel ?? 'Processing file records....' }}\r\n      </span>\r\n    </div>\r\n    <mat-progress-bar\r\n      *ngIf=\"importState === 'processing'\"\r\n      class=\"ieeesa-roster-import__progress-bar\"\r\n      mode=\"indeterminate\"\r\n      [attr.aria-label]=\"screenTexts?.processingLabel ?? 'Processing file records....'\"\r\n    ></mat-progress-bar>\r\n  </ng-container>\r\n\r\n  <!-- Result State (summary + errors) -->\r\n  <ng-container *ngIf=\"importState === 'result' && uploadResult\">\r\n    <!-- No data records banner (headers only, zero rows) -->\r\n    <div\r\n      *ngIf=\"noDataMessage\"\r\n      class=\"ieeesa-roster-import__no-data-banner\"\r\n      role=\"status\"\r\n    >\r\n      {{ noDataMessage }}\r\n    </div>\r\n\r\n    <!-- Summary cards -->\r\n    <div *ngIf=\"showSummaryCards\" class=\"ieeesa-roster-import__summary-cards\">\r\n      <div\r\n        class=\"ieeesa-roster-import__summary-card ieeesa-roster-import__summary-card--success\"\r\n      >\r\n        <p class=\"ieeesa-roster-import__summary-card-count\">\r\n          {{ uploadResult.successCount }}\r\n        </p>\r\n        <p class=\"ieeesa-roster-import__summary-card-label\">\r\n          {{ screenTexts?.result?.successCardLabel ?? 'Rosters added successfully' }}\r\n        </p>\r\n      </div>\r\n      <div\r\n        class=\"ieeesa-roster-import__summary-card ieeesa-roster-import__summary-card--skipped\"\r\n      >\r\n        <p class=\"ieeesa-roster-import__summary-card-count\">\r\n          {{ uploadResult.failureCount }}\r\n        </p>\r\n        <p class=\"ieeesa-roster-import__summary-card-label\">\r\n          {{ screenTexts?.result?.skippedCardLabel ?? 'Skipped Rows' }}\r\n        </p>\r\n      </div>\r\n    </div>\r\n\r\n    <!-- Row Errors Card -->\r\n    <div *ngIf=\"jobErrors.length\" class=\"ieeesa-roster-import__errors-card\">\r\n      <p class=\"ieeesa-roster-import__errors-header\">\r\n        <ng-container *ngIf=\"allRowsSkipped; else someErrors\">\r\n          {{ screenTexts?.result?.allRowsSkippedHeader ?? 'All Rows are skipped' }}\r\n        </ng-container>\r\n        <ng-template #someErrors>\r\n          {{ screenTexts?.result?.errorsHeader ?? 'Row errors — these rows will be skipped' }}\r\n        </ng-template>\r\n      </p>\r\n      <div class=\"ieeesa-roster-import__errors-body\">\r\n        <div\r\n          *ngFor=\"let rowErr of jobErrors\"\r\n          class=\"ieeesa-roster-import__error-row\"\r\n        >\r\n          <p class=\"ieeesa-roster-import__error-row-title\">\r\n            Row {{ rowErr.rowNumber }} — {{ rowErr.errorMessage }}\r\n          </p>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-container>\r\n\r\n  <!-- Footer actions -->\r\n  <div class=\"ieeesa-roster-import__actions\">\r\n    <button\r\n      mat-button\r\n      class=\"mat-tertiary-button ieeesa-roster-import__cancel-btn\"\r\n      (click)=\"onCancel()\"\r\n      type=\"button\"\r\n    >\r\n      {{ screenTexts?.buttons?.cancel ?? 'Cancel' }}\r\n    </button>\r\n    <button\r\n      *ngIf=\"importState === 'result' && jobErrors.length\"\r\n      mat-button\r\n      type=\"button\"\r\n      class=\"mat-primary-button ieeesa-roster-import__error-log-btn\"\r\n      (click)=\"downloadErrorLog()\"\r\n      [attr.aria-label]=\"screenTexts?.ariaLabel?.downloadErrorLog ?? 'Download Error log'\"\r\n    >\r\n      {{ screenTexts?.buttons?.downloadErrorLog ?? 'Download Error log' }}\r\n    </button>\r\n  </div>\r\n</div>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roster-import.component.js","sourceRoot":"","sources":["../../../../../../projects/groups/src/lib/components/roster-import/roster-import.component.ts","../../../../../../projects/groups/src/lib/components/roster-import/roster-import.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\nimport { Subject, switchMap, takeUntil } from 'rxjs';\r\nimport {\r\n  RosterImportErrorReport,\r\n  RosterImportJob,\r\n} from '../../models/roster-import.model';\r\nimport { RosterImportApiService } from '../../services/roster-import-api.service';\r\nimport { GroupsService } from '../../services/groups.service';\r\nimport * as constants from '../../assets/constants.json';\r\n\r\n/** States of the roster import flow. */\r\ntype RosterImportState = 'upload' | 'processing' | 'result';\r\n\r\n/**\r\n * View-model for the result screen. Populated from the confirmed\r\n * {@link RosterImportJob} returned by the backend.\r\n */\r\ninterface RosterImportResult {\r\n  totalRecords: number;\r\n  successCount: number;\r\n  failureCount: number;\r\n}\r\n\r\n/** Row error shown on the result screen (mapped from the BE error report). */\r\ninterface RosterImportRowError {\r\n  rowNumber: number;\r\n  field?: string;\r\n  errorMessage: string;\r\n}\r\n\r\n/**\r\n * Roster Import dialog.\r\n *\r\n * Lets an admin upload a CSV/XLSX roster file, shows a processing progress\r\n * bar, then a result summary (added / skipped) with per-row errors and an\r\n * error-log download.\r\n *\r\n * Wired to the real backend roster-import state machine\r\n * (sa-saapps-groups-api `RosterImportController`) via\r\n * {@link RosterImportApiService}: on Import it runs\r\n * upload → validate → confirm and renders the confirmed job's terminal counts\r\n * and per-row errors. Server-side validation errors (1072 unsupported format,\r\n * 1073 too large, 1074 row limit, 1075 invalid status) are surfaced inline.\r\n *\r\n * @export\r\n * @class RosterImportComponent\r\n */\r\n@Component({\r\n  selector: 'ieeesa-roster-import',\r\n  standalone: true,\r\n  imports: [CommonModule, MatButtonModule, MatProgressBarModule],\r\n  templateUrl: './roster-import.component.html',\r\n  styleUrls: ['./roster-import.component.scss'],\r\n  encapsulation: ViewEncapsulation.None,\r\n})\r\nexport class RosterImportComponent implements OnInit, OnDestroy {\r\n  /** Carries the { groupId, groupName } payload from the opening dialog. */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  @Input() componentData: any;\r\n\r\n  /** Emitted after an import that added at least one row (parent refreshes). */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  @Output() submitFormResponse = new EventEmitter<any>();\r\n\r\n  /** Emitted when the user cancels/closes without a successful add. */\r\n  @Output() formCancel = new EventEmitter<void>();\r\n\r\n  destroy$ = new Subject<boolean>();\r\n\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  constants: any = constants;\r\n  screenTexts = this.constants?.rosterImport;\r\n\r\n  /** Current state of the import flow. */\r\n  importState: RosterImportState = 'upload';\r\n\r\n  /** The selected file. */\r\n  selectedFile: File | null = null;\r\n\r\n  /** File drag-over state. */\r\n  isDragOver = false;\r\n\r\n  /** Terminal upload result. */\r\n  uploadResult: RosterImportResult | null = null;\r\n\r\n  /** Row-level errors for the completed job. */\r\n  jobErrors: RosterImportRowError[] = [];\r\n\r\n  /** Inline validation / API error message. */\r\n  errorMessage: string | null = null;\r\n\r\n  /**\r\n   * Info banner shown when the file has headers but no data rows\r\n   * (Figma: \"No roster data found...\").\r\n   */\r\n  noDataMessage: string | null = null;\r\n\r\n  /** The import job id returned by upload (kept so cancel can clean it up). */\r\n  private importId: string | null = null;\r\n\r\n  /** Maximum file size in bytes (10 MB) — matches the BE 10MB limit. */\r\n  readonly MAX_FILE_SIZE = 10_485_760;\r\n\r\n  /** Accepted file extensions (must match the BE contract: only .csv / .xlsx). */\r\n  readonly ACCEPTED_EXTENSIONS = ['.csv', '.xlsx'];\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private rosterImportApiService: RosterImportApiService,\r\n    // eslint-disable-next-line no-unused-vars\r\n    private groupService: GroupsService\r\n  ) {}\r\n\r\n  /**\r\n   * Required column headers for display and the sample file. This is the static\r\n   * base set from constants PLUS any tenant-level required profile fields the\r\n   * host app configured (e.g. phone / address / employer), mapped to friendly\r\n   * headers and de-duplicated (case-insensitive) against the base columns.\r\n   * @return {string[]}\r\n   */\r\n  get requiredColumns(): string[] {\r\n    const base: string[] = this.screenTexts?.requiredColumns ?? [];\r\n    return this.mergeTenantColumns(base);\r\n  }\r\n\r\n  /**\r\n   * Appends the tenant-configured columns (from {@link tenantExtraColumns}) to\r\n   * the base column headers.\r\n   * @param {string[]} base - The static base column headers.\r\n   * @return {string[]}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  private mergeTenantColumns(base: string[]): string[] {\r\n    const extras = this.tenantExtraColumns(base);\r\n    return extras.length ? [...base, ...extras.map((c) => c.label)] : base;\r\n  }\r\n\r\n  /**\r\n   * Resolves the tenant-configured required profile fields into the EXTRA\r\n   * columns to append after the base set — the single source of truth shared by\r\n   * both the header list ({@link requiredColumns}) and the sample file\r\n   * ({@link downloadSampleFile}) so the two never drift out of alignment.\r\n   *\r\n   * Each field becomes one column with its friendly `label` (known keys use the\r\n   * label map; unknown keys fall back to a title-cased key) and a `sampleValue`\r\n   * for the sample row. Fields whose label already exists in the base set\r\n   * (case-insensitive) are skipped so a tenant field like \"employer\" that is\r\n   * already a base column is not duplicated.\r\n   * @param {string[]} base - The static base column headers.\r\n   * @return {{ label: string; sampleValue: string }[]}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  private tenantExtraColumns(\r\n    base: string[]\r\n  ): { label: string; sampleValue: string }[] {\r\n    const tenantFields = this.groupService?.getRequiredProfileFields() ?? [];\r\n    if (!tenantFields.length) {\r\n      return [];\r\n    }\r\n    const sampleMap = this.screenTexts?.tenantFieldSampleValues ?? {};\r\n    const seen = new Set(base.map((col) => col.toLowerCase()));\r\n    const extras: { label: string; sampleValue: string }[] = [];\r\n    tenantFields.forEach((field) => {\r\n      const label = this.tenantFieldLabel(field);\r\n      if (label && !seen.has(label.toLowerCase())) {\r\n        seen.add(label.toLowerCase());\r\n        extras.push({ label, sampleValue: sampleMap[field] ?? '' });\r\n      }\r\n    });\r\n    return extras;\r\n  }\r\n\r\n  /**\r\n   * Maps a tenant field key to its display header. Known keys use the configured\r\n   * label map; unknown keys fall back to a title-cased key.\r\n   * @param {string} field - The tenant field key (e.g. 'phone').\r\n   * @return {string}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  private tenantFieldLabel(field: string): string {\r\n    const labels = this.screenTexts?.tenantFieldLabels ?? {};\r\n    if (labels[field]) {\r\n      return labels[field];\r\n    }\r\n    // Fallback: \"phone_number\" -> \"Phone Number\".\r\n    return field\r\n      .replace(/[_-]+/g, ' ')\r\n      .replace(/\\b\\w/g, (char) => char.toUpperCase());\r\n  }\r\n\r\n  /** Comma-separated accepted file types for the input element. */\r\n  get acceptedFileTypes(): string {\r\n    return this.ACCEPTED_EXTENSIONS.join(',');\r\n  }\r\n\r\n  /** The target group id from the dialog payload (falls back to selection). */\r\n  private get groupId(): string {\r\n    return (\r\n      this.componentData?.groupId ??\r\n      (this.groupService?.getSelectedGroupInfo()?.groupId as string) ??\r\n      ''\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Sets the API base URL on the import service.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  ngOnInit(): void {\r\n    this.rosterImportApiService.setApiBaseUrl(this.groupService?.apiBaseUrl);\r\n  }\r\n\r\n  /**\r\n   * Cleans up subscriptions when the component is destroyed.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next(true);\r\n    this.destroy$.complete();\r\n  }\r\n\r\n  /**\r\n   * Handles a file selected via the browse dialog.\r\n   * @param {Event} event - The change event from the hidden file input.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onFileSelected(event: Event): void {\r\n    const input = event.target as HTMLInputElement;\r\n    if (!input.files || input.files.length === 0) {\r\n      return;\r\n    }\r\n    if (input.files.length > 1) {\r\n      this.showSingleFileOnlyError();\r\n      return;\r\n    }\r\n    this.processFile(input.files[0]);\r\n  }\r\n\r\n  /**\r\n   * Handles a file dropped onto the dropzone.\r\n   * @param {DragEvent} event - The drop event.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onFileDrop(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    this.isDragOver = false;\r\n    const files = event.dataTransfer?.files;\r\n    if (!files || files.length === 0) {\r\n      return;\r\n    }\r\n    if (files.length > 1) {\r\n      this.showSingleFileOnlyError();\r\n      return;\r\n    }\r\n    this.processFile(files[0]);\r\n  }\r\n\r\n  /**\r\n   * Handles drag-over on the dropzone.\r\n   * @param {DragEvent} event - The dragover event.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onDragOver(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    this.isDragOver = true;\r\n  }\r\n\r\n  /**\r\n   * Handles drag-leave on the dropzone.\r\n   * @param {DragEvent} event - The dragleave event.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onDragLeave(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    this.isDragOver = false;\r\n  }\r\n\r\n  /**\r\n   * Validates the file type and size, then either sets it or shows an error.\r\n   * @param {File} file - The candidate file.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  processFile(file: File): void {\r\n    this.errorMessage = null;\r\n    this.noDataMessage = null;\r\n    this.uploadResult = null;\r\n    this.importId = null;\r\n    // Clear any previously selected (valid) file so an invalid new selection\r\n    // can't leave the Import button enabled for a stale file.\r\n    this.selectedFile = null;\r\n\r\n    const fileName = file.name.toLowerCase();\r\n    const isValidExtension = this.ACCEPTED_EXTENSIONS.some((ext) =>\r\n      fileName.endsWith(ext)\r\n    );\r\n    if (!isValidExtension) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.unsupportedType ??\r\n        'Incorrect file type. Please upload a valid .csv or .xlsx file.';\r\n      return;\r\n    }\r\n\r\n    if (file.size === 0) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.emptyFile ??\r\n        'The selected file is empty. Please upload a file with roster records.';\r\n      return;\r\n    }\r\n\r\n    if (file.size > this.MAX_FILE_SIZE) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.fileTooLarge ??\r\n        'File size exceeds the maximum allowed size of 10MB.';\r\n      return;\r\n    }\r\n\r\n    this.selectedFile = file;\r\n  }\r\n\r\n  /**\r\n   * Shows the single-file-only validation message.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  showSingleFileOnlyError(): void {\r\n    this.errorMessage =\r\n      this.screenTexts?.validation?.singleFileOnly ??\r\n      'Please upload a single file at a time.';\r\n  }\r\n\r\n  /**\r\n   * Removes the currently selected file and resets to the upload state.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onRemoveFile(): void {\r\n    this.selectedFile = null;\r\n    this.errorMessage = null;\r\n    this.noDataMessage = null;\r\n    this.uploadResult = null;\r\n    this.importId = null;\r\n    this.importState = 'upload';\r\n  }\r\n\r\n  /**\r\n   * Runs the real import: upload → validate → confirm. The progress bar is\r\n   * shown in indeterminate mode while the chain is in flight, then the\r\n   * confirmed job's terminal counts + per-row errors drive the result screen.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onImport(): void {\r\n    if (!this.selectedFile) {\r\n      return;\r\n    }\r\n    if (!this.groupId) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.uploadFailed ??\r\n        'An error occurred while importing the roster. Please try again.';\r\n      return;\r\n    }\r\n    this.errorMessage = null;\r\n    this.noDataMessage = null;\r\n    this.uploadResult = null;\r\n    this.jobErrors = [];\r\n    this.importId = null;\r\n    this.importState = 'processing';\r\n\r\n    this.rosterImportApiService\r\n      .uploadImportFile(this.selectedFile, this.groupId)\r\n      .pipe(\r\n        switchMap((job: RosterImportJob) => {\r\n          this.importId = job?.importId ?? null;\r\n          return this.rosterImportApiService.validateImportJob(\r\n            this.importId as string\r\n          );\r\n        }),\r\n        switchMap(() =>\r\n          this.rosterImportApiService.confirmImportJob(this.importId as string)\r\n        ),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe({\r\n        next: (confirmedJob: RosterImportJob) => {\r\n          this.finalizeResult(confirmedJob);\r\n        },\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        error: (error: any) => {\r\n          this.handleImportError(error);\r\n        },\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Maps a failed import call to an inline error message and returns the UI to\r\n   * the upload state so the user can retry. Known BE error codes (1072–1075)\r\n   * are mapped via constants; anything else uses the generic message.\r\n   * @param {*} error - The HttpErrorResponse.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  private handleImportError(error: any): void {\r\n    this.importState = 'upload';\r\n\r\n    // BE error codes take priority when present (e.g. 1071 no permission, 1072\r\n    // format, 1073 too large, 1074 row limit, 1075 invalid status).\r\n    const errorCodes: string[] | undefined = error?.error?.body?.errorCodes;\r\n    if (Array.isArray(errorCodes) && errorCodes.length) {\r\n      const code = errorCodes[0] as keyof typeof this.constants.errors;\r\n      this.errorMessage =\r\n        this.constants?.errors?.[code] ??\r\n        this.screenTexts?.validation?.uploadFailed ??\r\n        'An error occurred while importing the roster. Please try again.';\r\n      return;\r\n    }\r\n\r\n    // A 403 with no error-code body comes from the endpoint's @PreAuthorize\r\n    // (the user lacks Manage Group Member / Manage All Rosters for this group).\r\n    // Show the permission message — retrying will not help.\r\n    const status = error?.status ?? error?.error?.status;\r\n    if (status === 403) {\r\n      this.errorMessage =\r\n        this.screenTexts?.validation?.forbidden ??\r\n        'You do not have permission to import a roster for this group.';\r\n      return;\r\n    }\r\n\r\n    this.errorMessage =\r\n      this.screenTexts?.validation?.uploadFailed ??\r\n      'An error occurred while importing the roster. Please try again.';\r\n  }\r\n\r\n  /**\r\n   * Stores the terminal result and moves to the result state. When the job had\r\n   * no data rows, shows the \"no roster data\" info banner instead of the summary\r\n   * cards.\r\n   * @param {RosterImportJob} job - The confirmed import job.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  finalizeResult(job: RosterImportJob): void {\r\n    const totalRecords = job?.totalRows ?? 0;\r\n    const successCount = job?.successRows ?? 0;\r\n    const failureCount = job?.failedRows ?? 0;\r\n\r\n    this.uploadResult = { totalRecords, successCount, failureCount };\r\n    this.jobErrors = this.parseErrorReport(job?.errorReport);\r\n    this.importState = 'result';\r\n\r\n    if (totalRecords === 0) {\r\n      this.noDataMessage =\r\n        this.screenTexts?.validation?.noDataRecords ??\r\n        'No roster data found. The selected file contains headers but no roster records.';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Normalizes the BE `error_report` into row-error view models.\r\n   *\r\n   * The BE wraps the per-row entries in a `{ rows: [ { row, field, message } ] }`\r\n   * document, but that value has been observed to arrive in MULTIPLE shapes:\r\n   *  - a parsed object `{ rows: [...] }` (confirm response — the common case),\r\n   *  - a raw JSON string of the same object (JSONB passthrough), or\r\n   *  - a bare array `[ { row, field, message } ]`.\r\n   * This handles all three (and `null`) so the error log renders regardless of\r\n   * how the field is serialized.\r\n   * @param {*} errorReport - The BE error_report (object, string, array, or null).\r\n   * @return {RosterImportRowError[]}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  private parseErrorReport(errorReport?: any): RosterImportRowError[] {\r\n    if (!errorReport) {\r\n      return [];\r\n    }\r\n    // If it's a string, parse it first; on parse failure, no row errors.\r\n    let value: unknown = errorReport;\r\n    if (typeof errorReport === 'string') {\r\n      try {\r\n        value = JSON.parse(errorReport);\r\n      } catch {\r\n        return [];\r\n      }\r\n    }\r\n    // Accept either a bare array or a { rows: [...] } wrapper object.\r\n    const entries: RosterImportErrorReport[] = Array.isArray(value)\r\n      ? (value as RosterImportErrorReport[])\r\n      : ((value as { rows?: RosterImportErrorReport[] })?.rows ?? []);\r\n    return entries.map((entry) => ({\r\n      rowNumber: entry?.row,\r\n      field: entry?.field,\r\n      errorMessage: entry?.message,\r\n    }));\r\n  }\r\n\r\n  /**\r\n   * Whether the result state should show the summary cards (added / skipped).\r\n   * Hidden for the \"no data records\" case.\r\n   * @return {boolean}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  get showSummaryCards(): boolean {\r\n    return !!this.uploadResult && this.uploadResult.totalRecords > 0;\r\n  }\r\n\r\n  /**\r\n   * Whether every processed row was skipped (drives the \"All Rows are skipped\"\r\n   * header on the errors card).\r\n   * @return {boolean}\r\n   * @memberof RosterImportComponent\r\n   */\r\n  get allRowsSkipped(): boolean {\r\n    return (\r\n      !!this.uploadResult &&\r\n      this.uploadResult.totalRecords > 0 &&\r\n      this.uploadResult.successCount === 0\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Builds a client-side CSV sample file from the required columns and triggers\r\n   * a browser download. (Client-side generation until the template API exists.)\r\n   * @memberof RosterImportComponent\r\n   */\r\n  downloadSampleFile(): void {\r\n    const headerLine = this.requiredColumns\r\n      .map((col) => this.toCsvCell(col))\r\n      .join(',');\r\n\r\n    // Sample data rows so the downloaded file shows the expected format, not\r\n    // just the column headers. The base row values come from constants; sample\r\n    // values for any tenant-configured columns are appended (from the SAME\r\n    // source that builds the headers) so every row lines up with the\r\n    // (base + tenant) header set.\r\n    const base: string[] = this.screenTexts?.requiredColumns ?? [];\r\n    const baseSampleRows: string[][] = this.screenTexts?.sampleRows ?? [];\r\n    const tenantSampleCells = this.tenantExtraColumns(base).map(\r\n      (col) => col.sampleValue\r\n    );\r\n    const dataLines = baseSampleRows.map((row) =>\r\n      [...row, ...tenantSampleCells]\r\n        .map((cell) => this.toCsvCell(cell))\r\n        .join(',')\r\n    );\r\n\r\n    const csvContent = [headerLine, ...dataLines].join('\\r\\n') + '\\r\\n';\r\n    const blob = new Blob([csvContent], {\r\n      type: 'text/csv;charset=utf-8;',\r\n    });\r\n    const fileName = this.screenTexts?.sampleFileName ?? 'Roster_Sample.csv';\r\n    this.triggerDownload(blob, fileName);\r\n  }\r\n\r\n  /**\r\n   * Builds a CSV from the row-level errors and triggers a browser download so\r\n   * the user can correct and re-upload.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  downloadErrorLog(): void {\r\n    if (!this.jobErrors.length) {\r\n      return;\r\n    }\r\n    const headers: string[] = this.screenTexts?.errorLog?.headers ?? [\r\n      'Row',\r\n      'Field',\r\n      'Error',\r\n    ];\r\n    const rows = this.jobErrors.map((rowErr) =>\r\n      [rowErr.rowNumber, rowErr.field, rowErr.errorMessage]\r\n        .map((value) => this.toCsvCell(value))\r\n        .join(',')\r\n    );\r\n    const csvContent = [\r\n      headers.map((header) => this.toCsvCell(header)).join(','),\r\n      ...rows,\r\n    ].join('\\r\\n');\r\n    const fileName =\r\n      this.screenTexts?.errorLog?.fileName ?? 'Roster_Import_Error_Log.csv';\r\n    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\r\n    this.triggerDownload(blob, fileName);\r\n  }\r\n\r\n  /**\r\n   * Escapes a value for safe inclusion in a CSV cell.\r\n   * @param {(string | number | undefined | null)} value - The raw cell value.\r\n   * @return {string} - the CSV-safe cell string.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  toCsvCell(value: string | number | undefined | null): string {\r\n    const raw = value === undefined || value === null ? '' : String(value);\r\n    if (/[\",\\r\\n]/.test(raw)) {\r\n      return `\"${raw.replace(/\"/g, '\"\"')}\"`;\r\n    }\r\n    return raw;\r\n  }\r\n\r\n  /**\r\n   * Closes the dialog. Emits submitFormResponse when at least one row was added\r\n   * so the parent refreshes; otherwise emits formCancel.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  onCancel(): void {\r\n    if (this.uploadResult && this.uploadResult.successCount > 0) {\r\n      this.submitFormResponse.emit(this.uploadResult);\r\n    } else {\r\n      this.formCancel.emit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Triggers a browser download for a generated blob.\r\n   * @param {Blob} blob - The file content.\r\n   * @param {string} fileName - The suggested filename.\r\n   * @memberof RosterImportComponent\r\n   */\r\n  private triggerDownload(blob: Blob, fileName: string): void {\r\n    const url = URL.createObjectURL(blob);\r\n    const link = document.createElement('a');\r\n    link.href = url;\r\n    link.download = fileName;\r\n    link.click();\r\n    URL.revokeObjectURL(url);\r\n  }\r\n}\r\n","<div class=\"ieeesa-roster-import\">\r\n  <!-- Sub-heading band: \"Bulk Import Participants\" on the left, Import Roster\r\n       action on the right (appears once a file is selected) — matches the Figma.\r\n       The \"← Back to Rosters / Import Roster\" title row + X are rendered by the\r\n       shared ModalComponent above this. -->\r\n  <div class=\"ieeesa-roster-import__subheader\">\r\n    <span class=\"ieeesa-roster-import__subheader-title\">\r\n      {{ screenTexts?.subHeading ?? 'Bulk Import Participants' }}\r\n    </span>\r\n    <button\r\n      *ngIf=\"selectedFile\"\r\n      mat-button\r\n      type=\"button\"\r\n      class=\"mat-tertiary-button ieeesa-roster-import__import-btn\"\r\n      [disabled]=\"importState === 'processing'\"\r\n      (click)=\"onImport()\"\r\n      [attr.aria-label]=\"screenTexts?.buttons?.import ?? 'Import Roster'\"\r\n    >\r\n      <svg class=\"ieeesa-roster-import__import-btn-icon\" width=\"14\" height=\"14\" aria-hidden=\"true\">\r\n        <use xlink:href=\"assets/images/sprites/sprites.svg#icon-import\"></use>\r\n      </svg>\r\n      {{ screenTexts?.buttons?.import ?? 'Import Roster' }}\r\n    </button>\r\n  </div>\r\n\r\n  <!-- Required Columns Info -->\r\n  <div class=\"ieeesa-roster-import__columns-card\">\r\n    <div class=\"ieeesa-roster-import__columns-content\">\r\n      <p class=\"ieeesa-roster-import__columns-title\">\r\n        {{ screenTexts?.requiredColumnsTitle ?? 'Required columns' }}\r\n      </p>\r\n      <div class=\"ieeesa-roster-import__columns-chips\">\r\n        <span\r\n          *ngFor=\"let col of requiredColumns\"\r\n          class=\"ieeesa-roster-import__chip\"\r\n        >\r\n          {{ col }}\r\n        </span>\r\n      </div>\r\n    </div>\r\n    <div class=\"ieeesa-roster-import__sample-wrapper\">\r\n      <button\r\n        mat-button\r\n        class=\"mat-tertiary-button ieeesa-roster-import__download-btn\"\r\n        (click)=\"downloadSampleFile()\"\r\n        type=\"button\"\r\n        [attr.aria-label]=\"screenTexts?.ariaLabel?.downloadSample ?? 'Download Sample File'\"\r\n      >\r\n        <svg\r\n          class=\"ieeesa-roster-import__download-btn-icon\"\r\n          aria-hidden=\"true\"\r\n        >\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-file-doc\"></use>\r\n        </svg>\r\n        {{ screenTexts?.downloadSampleLabel ?? 'Download Sample File' }}\r\n      </button>\r\n    </div>\r\n  </div>\r\n\r\n  <p class=\"ieeesa-roster-import__upload-label\">\r\n    {{ screenTexts?.uploadLabel ?? 'Upload your file' }}\r\n  </p>\r\n\r\n  <!-- Upload State -->\r\n  <ng-container *ngIf=\"importState === 'upload'\">\r\n    <!-- Hidden file input -->\r\n    <input\r\n      #fileInput\r\n      type=\"file\"\r\n      [accept]=\"acceptedFileTypes\"\r\n      (change)=\"onFileSelected($event)\"\r\n      hidden\r\n      [attr.aria-label]=\"screenTexts?.uploadLabel ?? 'Upload your file'\"\r\n    />\r\n\r\n    <!-- Drag & Drop Zone -->\r\n    <div\r\n      class=\"ieeesa-roster-import__dropzone\"\r\n      [class.ieeesa-roster-import__dropzone--active]=\"isDragOver\"\r\n      (dragover)=\"onDragOver($event)\"\r\n      (dragleave)=\"onDragLeave($event)\"\r\n      (drop)=\"onFileDrop($event)\"\r\n      (click)=\"fileInput.click()\"\r\n      role=\"button\"\r\n      tabindex=\"0\"\r\n      (keydown.enter)=\"fileInput.click()\"\r\n      (keydown.space)=\"fileInput.click()\"\r\n      [attr.aria-label]=\"screenTexts?.ariaLabel?.dropzone ?? 'Drag and drop file upload area'\"\r\n    >\r\n      <ng-container *ngIf=\"!selectedFile\">\r\n        <svg class=\"ieeesa-roster-import__upload-icon\" width=\"22\" height=\"22\">\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-upload-gray\"></use>\r\n        </svg>\r\n        <p class=\"ieeesa-roster-import__dropzone-text\">\r\n          {{ screenTexts?.dropzoneText ?? 'Drag & drop a file here, or click to browse' }}\r\n        </p>\r\n        <p class=\"ieeesa-roster-import__dropzone-hint\">\r\n          {{ screenTexts?.dropzoneHint ?? 'Accepted formats: .csv, .xlsx' }}\r\n        </p>\r\n      </ng-container>\r\n      <ng-container *ngIf=\"selectedFile\">\r\n        <svg class=\"ieeesa-roster-import__upload-icon\" width=\"22\" height=\"22\">\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-upload-gray\"></use>\r\n        </svg>\r\n        <div class=\"ieeesa-roster-import__file-row\">\r\n          <p class=\"ieeesa-roster-import__file-name\">\r\n            <svg width=\"14\" height=\"14\">\r\n              <use xlink:href=\"assets/images/sprites/sprites.svg#icon-file-doc\"></use>\r\n            </svg>\r\n            {{ selectedFile.name }}\r\n          </p>\r\n          <button\r\n            mat-button\r\n            class=\"ieeesa-roster-import__remove-file-btn\"\r\n            (click)=\"onRemoveFile(); $event.stopPropagation()\"\r\n            type=\"button\"\r\n            [attr.aria-label]=\"screenTexts?.ariaLabel?.remove ?? 'Remove selected file'\"\r\n          >\r\n            &times;\r\n          </button>\r\n        </div>\r\n      </ng-container>\r\n    </div>\r\n\r\n    <!-- Inline Error Message -->\r\n    <div\r\n      *ngIf=\"errorMessage\"\r\n      class=\"ieeesa-roster-import__error-banner\"\r\n      role=\"alert\"\r\n    >\r\n      {{ errorMessage }}\r\n    </div>\r\n  </ng-container>\r\n\r\n  <!-- Processing / Result share the file display + progress bar -->\r\n  <ng-container *ngIf=\"importState === 'processing' || importState === 'result'\">\r\n    <div\r\n      class=\"ieeesa-roster-import__dropzone ieeesa-roster-import__dropzone--result\"\r\n    >\r\n      <svg class=\"ieeesa-roster-import__upload-icon\" width=\"22\" height=\"22\">\r\n        <use xlink:href=\"assets/images/sprites/sprites.svg#icon-upload-gray\"></use>\r\n      </svg>\r\n      <p class=\"ieeesa-roster-import__file-name\">\r\n        <svg width=\"14\" height=\"14\">\r\n          <use xlink:href=\"assets/images/sprites/sprites.svg#icon-file-doc\"></use>\r\n        </svg>\r\n        {{ selectedFile?.name }}\r\n      </p>\r\n    </div>\r\n\r\n    <!-- Progress label (processing only) -->\r\n    <div\r\n      *ngIf=\"importState === 'processing'\"\r\n      class=\"ieeesa-roster-import__progress-head\"\r\n    >\r\n      <span class=\"ieeesa-roster-import__progress-label\">\r\n        {{ screenTexts?.processingLabel ?? 'Processing file records....' }}\r\n      </span>\r\n    </div>\r\n    <mat-progress-bar\r\n      *ngIf=\"importState === 'processing'\"\r\n      class=\"ieeesa-roster-import__progress-bar\"\r\n      mode=\"indeterminate\"\r\n      [attr.aria-label]=\"screenTexts?.processingLabel ?? 'Processing file records....'\"\r\n    ></mat-progress-bar>\r\n  </ng-container>\r\n\r\n  <!-- Result State (summary + errors) -->\r\n  <ng-container *ngIf=\"importState === 'result' && uploadResult\">\r\n    <!-- No data records banner (headers only, zero rows) -->\r\n    <div\r\n      *ngIf=\"noDataMessage\"\r\n      class=\"ieeesa-roster-import__no-data-banner\"\r\n      role=\"status\"\r\n    >\r\n      {{ noDataMessage }}\r\n    </div>\r\n\r\n    <!-- Summary cards -->\r\n    <div *ngIf=\"showSummaryCards\" class=\"ieeesa-roster-import__summary-cards\">\r\n      <div\r\n        class=\"ieeesa-roster-import__summary-card ieeesa-roster-import__summary-card--success\"\r\n      >\r\n        <p class=\"ieeesa-roster-import__summary-card-count\">\r\n          {{ uploadResult.successCount }}\r\n        </p>\r\n        <p class=\"ieeesa-roster-import__summary-card-label\">\r\n          {{ screenTexts?.result?.successCardLabel ?? 'Rosters added successfully' }}\r\n        </p>\r\n      </div>\r\n      <div\r\n        class=\"ieeesa-roster-import__summary-card ieeesa-roster-import__summary-card--skipped\"\r\n      >\r\n        <p class=\"ieeesa-roster-import__summary-card-count\">\r\n          {{ uploadResult.failureCount }}\r\n        </p>\r\n        <p class=\"ieeesa-roster-import__summary-card-label\">\r\n          {{ screenTexts?.result?.skippedCardLabel ?? 'Skipped Rows' }}\r\n        </p>\r\n      </div>\r\n    </div>\r\n\r\n    <!-- Row Errors Card -->\r\n    <div *ngIf=\"jobErrors.length\" class=\"ieeesa-roster-import__errors-card\">\r\n      <p class=\"ieeesa-roster-import__errors-header\">\r\n        <ng-container *ngIf=\"allRowsSkipped; else someErrors\">\r\n          {{ screenTexts?.result?.allRowsSkippedHeader ?? 'All Rows are skipped' }}\r\n        </ng-container>\r\n        <ng-template #someErrors>\r\n          {{ screenTexts?.result?.errorsHeader ?? 'Row errors — these rows will be skipped' }}\r\n        </ng-template>\r\n      </p>\r\n      <div class=\"ieeesa-roster-import__errors-body\">\r\n        <div\r\n          *ngFor=\"let rowErr of jobErrors\"\r\n          class=\"ieeesa-roster-import__error-row\"\r\n        >\r\n          <p class=\"ieeesa-roster-import__error-row-title\">\r\n            Row {{ rowErr.rowNumber }} — {{ rowErr.errorMessage }}\r\n          </p>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </ng-container>\r\n\r\n  <!-- Footer actions -->\r\n  <div class=\"ieeesa-roster-import__actions\">\r\n    <button\r\n      mat-button\r\n      class=\"mat-tertiary-button ieeesa-roster-import__cancel-btn\"\r\n      (click)=\"onCancel()\"\r\n      type=\"button\"\r\n    >\r\n      {{ screenTexts?.buttons?.cancel ?? 'Cancel' }}\r\n    </button>\r\n    <button\r\n      *ngIf=\"importState === 'result' && jobErrors.length\"\r\n      mat-button\r\n      type=\"button\"\r\n      class=\"mat-primary-button ieeesa-roster-import__error-log-btn\"\r\n      (click)=\"downloadErrorLog()\"\r\n      [attr.aria-label]=\"screenTexts?.ariaLabel?.downloadErrorLog ?? 'Download Error log'\"\r\n    >\r\n      {{ screenTexts?.buttons?.downloadErrorLog ?? 'Download Error log' }}\r\n    </button>\r\n  </div>\r\n</div>\r\n"]}