@tuki-io/tuki-widgets 0.0.219-dev.54 → 0.0.219-dev.55

package/esm2020/contact-center/cc-import/cc-import.module.mjs

@@ -0,0 +1,45 @@
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { MatStepperModule } from '@angular/material/stepper';
+import { NgApexchartsModule } from 'ng-apexcharts';
+import { SharedModule } from '../shared/shared.module';
+import { ImportContactCenterPanelComponent } from './components/import-contact-center-panel/import-contact-center-panel.component';
+import { ImportContactCenterWizardComponent } from './components/import-contact-center-wizard/import-contact-center-wizard.component';
+import * as i0 from "@angular/core";
+export class CcImportModule {
+}
+CcImportModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CcImportModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CcImportModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: CcImportModule, declarations: [ImportContactCenterPanelComponent,
+        ImportContactCenterWizardComponent], imports: [CommonModule,
+        HttpClientModule,
+        NgApexchartsModule,
+        MatStepperModule,
+        SharedModule], exports: [ImportContactCenterPanelComponent,
+        ImportContactCenterWizardComponent] });
+CcImportModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CcImportModule, imports: [CommonModule,
+        HttpClientModule,
+        NgApexchartsModule,
+        MatStepperModule,
+        SharedModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CcImportModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ImportContactCenterPanelComponent,
+                        ImportContactCenterWizardComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        NgApexchartsModule,
+                        MatStepperModule,
+                        SharedModule
+                    ],
+                    exports: [
+                        ImportContactCenterPanelComponent,
+                        ImportContactCenterWizardComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/contact-center/cc-import/cc-import.service.mjs

@@ -0,0 +1,228 @@
+import { inject, Injectable } from '@angular/core';
+import { delay, forkJoin, map, of, switchMap } from 'rxjs';
+import { API } from '../shared/api.endpoints';
+import { APIService } from '../shared/api.service';
+import { DcpApiService } from '../shared/dcp-api.service';
+import { COMPATIBILITY_THRESHOLDS, OVERVIEW_ENTITY_GROUPS } from './constants/cc-import.constants';
+import { mockContactCenterEntities, mockContactCenters } from './mock/cc-import.mock';
+import { CALL_FLOW_MIGRATED } from './types/uccx';
+import * as i0 from "@angular/core";
+/** Simulated network latency for the mock responses, so loading states are exercised. */
+const MOCK_LATENCY_MS = 300;
+export class CcImportService {
+    constructor() {
+        this.api = inject(APIService);
+        this.dcpApi = inject(DcpApiService);
+        /**
+         * Answer everything from `mock/cc-import.mock.ts` instead of calling the backend.
+         *
+         * Note this is all-or-nothing: with it off, the contact-center list, the entity
+         * overview and the import all hit real endpoints. Compatibility scoring is the
+         * exception - see {@link resolveCompatibility}.
+         */
+        this.useMockData = true;
+    }
+    setToken(token) {
+        this.api.token = token;
+        this.dcpApi.token = token;
+    }
+    setHost(host) {
+        this.api.apiUrl = host;
+    }
+    /** Base URL of the dcp host, which serves the UCCX application list. */
+    setDcpHost(dcpHost) {
+        this.dcpApi.apiUrl = dcpHost;
+    }
+    /**
+     * Every UCCX contact center Tuki can import.
+     *
+     * A "contact center" is a UCCX application. The list comes from the dcp
+     * application cache; whether each one has already been imported is joined on from
+     * the per-AEF-script call-flow migration states.
+     */
+    fetchContactCenters(customerId) {
+        if (this.useMockData) {
+            return of(mockContactCenters()).pipe(delay(MOCK_LATENCY_MS));
+        }
+        return forkJoin({
+            applications: this.dcpApi.fetch(API.UCCX.APPLICATION_NAMES(customerId)),
+            callFlows: this.api.fetch(API.UCCX.CALL_FLOW_MIGRATION_STATUSES(customerId))
+        }).pipe(map(({ applications, callFlows }) => this.toContactCenters(this.asArray(applications), this.asArray(callFlows))));
+    }
+    /**
+     * Application-centric entity breakdown: everything Tuki will create on import.
+     *
+     * Note this only ever returns entities the backend has actually linked to the
+     * application. Where that linkage is missing the groups come back empty rather
+     * than padded with unrelated entities of the right type.
+     */
+    fetchContactCenterEntities(customerId, contactCenter) {
+        if (this.useMockData) {
+            return of(mockContactCenterEntities(contactCenter)).pipe(delay(MOCK_LATENCY_MS));
+        }
+        return this.fetchApplicationItems(customerId, contactCenter.applicationName).pipe(map(items => ({
+            applicationId: contactCenter.applicationId,
+            groups: this.groupEntities(items)
+        })));
+    }
+    /**
+     * Kicks off the UCCX -> Webex Contact Center import of one contact center, as a
+     * single migration unit: every entity of the application goes in one request.
+     *
+     * The endpoint is synchronous and answers with an XLSX tracker rather than a job
+     * id - execution and progress tracking are defined in a separate ticket.
+     *
+     * @param siteId     required by the backend when a Resource Group is in scope.
+     * @param locationId required by the backend when a Trigger is in scope.
+     */
+    importContactCenter(customerId, applicationId, siteId, locationId) {
+        if (this.useMockData) {
+            return of({ applicationId, accepted: true }).pipe(delay(MOCK_LATENCY_MS));
+        }
+        return this.fetchApplicationItems(customerId, applicationId).pipe(switchMap(items => {
+            const payload = {
+                uccxItemsList: items.length ? [items.map(item => ({ ...item, migrate: true }))] : []
+            };
+            return this.api.post(API.UCCX.MIGRATE(customerId), payload, { siteId, locationId }, { responseType: 'blob' });
+        }), map((report) => ({
+            applicationId,
+            accepted: true,
+            report: report instanceof Blob ? report : undefined
+        })));
+    }
+    /**
+     * Every UCCX entity belonging to one application, gathered across the batches.
+     *
+     * UCCX batches hold one entity type each, so this reads them all and keeps the
+     * items whose `applicationName` matches. The narrowing is done here rather than
+     * through the endpoint's own `applicationName` param because that param answers
+     * `[]` on dev2 even for items that plainly carry the name.
+     */
+    fetchApplicationItems(customerId, applicationName) {
+        return this.api.fetch(API.UCCX.BATCHES(customerId)).pipe(switchMap(response => {
+            const batches = this.asArray(response);
+            if (!batches.length) {
+                return of([]);
+            }
+            return forkJoin(batches.map(batch => this.api.fetch(API.UCCX.BATCH_ITEMS(customerId, batch.id))
+                .pipe(map((wrapper) => this.flattenItems(wrapper))))).pipe(map(perBatch => this.dedupeItems(perBatch.flat().filter(item => item.applicationName === applicationName))));
+        }));
+    }
+    /** The items endpoint nests items one level; older responses come back flat. */
+    flattenItems(wrapper) {
+        const items = wrapper?.uccxItemsList ?? [];
+        const flattened = Array.isArray(items[0])
+            ? items.flat()
+            : items;
+        return flattened.filter(Boolean);
+    }
+    /** The same entity can be carried by more than one batch. */
+    dedupeItems(items) {
+        const seen = new Set();
+        return items.filter(item => {
+            const key = `${item.type}::${item.name}::${item.sourceUCCXIp}`;
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+    }
+    groupEntities(items) {
+        const remaining = new Map();
+        items.forEach(item => {
+            const names = remaining.get(item.type) ?? [];
+            names.push(item.name);
+            remaining.set(item.type, names);
+        });
+        const groups = OVERVIEW_ENTITY_GROUPS.map(group => {
+            const collected = [];
+            group.types.forEach(type => {
+                collected.push(...(remaining.get(type) ?? []));
+                remaining.delete(type);
+            });
+            return { label: group.label, items: collected };
+        });
+        // Anything the backend returned that has no group of its own keeps its raw
+        // type as a label, rather than being dropped from the overview.
+        remaining.forEach((names, type) => groups.push({ label: type, items: names }));
+        return groups;
+    }
+    toContactCenters(applications, callFlows) {
+        return applications
+            .filter(application => !!application?.name)
+            .map(application => {
+            const uccxIp = application.uccx?.host;
+            const scriptName = this.toScriptName(application);
+            const compatibilityStatus = this.resolveCompatibility(application);
+            const contactCenter = {
+                // UCCX identifies an application by name - it is what the entity
+                // records link back to - so it doubles as the widget's key.
+                applicationId: application.name,
+                applicationName: application.name,
+                scriptName,
+                uccxIp,
+                compatibilityStatus,
+                migrationState: this.resolveMigrationState(application, scriptName, uccxIp, callFlows),
+                // Per the ticket, "requires review" is exactly the set that can go
+                // to either destination.
+                customerAssistCapable: compatibilityStatus === 'requires-review'
+            };
+            return contactCenter;
+        });
+    }
+    /** UCCX wraps the backing script as `SCRIPT[Foo.aef]`; the widget shows `Foo.aef`. */
+    toScriptName(application) {
+        const raw = application.scriptName ?? application.aefFiles?.[0] ?? '';
+        return raw.replace(/^SCRIPT\[(.*)\]$/, '$1');
+    }
+    /**
+     * Whether Tuki has already imported this contact center.
+     *
+     * The application record carries its own `migrationStatus`, but it is null
+     * throughout dev2, so this falls back to the per-AEF-script call-flow state.
+     */
+    resolveMigrationState(application, scriptName, uccxIp, callFlows) {
+        if (application.migrationStatus) {
+            return application.migrationStatus === CALL_FLOW_MIGRATED ? 'migrated' : 'not-migrated';
+        }
+        const callFlow = callFlows.find(flow => flow.scriptName === scriptName && (!uccxIp || flow.uccxIp === uccxIp));
+        return callFlow?.status === CALL_FLOW_MIGRATED ? 'migrated' : 'not-migrated';
+    }
+    /**
+     * Turns an AEF compatibility score into a status.
+     *
+     * The scoring API does not exist yet - the AEF step mapping is still a pending
+     * input on the ticket - so when the backend sends no score every contact center
+     * falls back to "requires review": the status that offers both destinations and
+     * claims nothing about compatibility we have not actually measured.
+     *
+     * Once the backend returns `compatibilityScore`, the thresholds below take over
+     * with no further change here.
+     */
+    resolveCompatibility(application) {
+        const score = application.compatibilityScore;
+        if (typeof score !== 'number') {
+            return 'requires-review';
+        }
+        if (score >= COMPATIBILITY_THRESHOLDS.migratable) {
+            return 'migratable';
+        }
+        if (score >= COMPATIBILITY_THRESHOLDS.requiresReview) {
+            return 'requires-review';
+        }
+        return 'unsupported';
+    }
+    asArray(value) {
+        return Array.isArray(value) ? value : [];
+    }
+}
+CcImportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CcImportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CcImportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CcImportService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CcImportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cc-import.service.js","sourceRoot":"","sources":["../../../../../../projects/tuki/widgets/contact-center/cc-import/cc-import.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { Observable, delay, forkJoin, map, of, switchMap } from 'rxjs';\r\nimport { API } from '../shared/api.endpoints';\r\nimport { APIService } from '../shared/api.service';\r\nimport { DcpApiService } from '../shared/dcp-api.service';\r\nimport { COMPATIBILITY_THRESHOLDS, OVERVIEW_ENTITY_GROUPS } from './constants/cc-import.constants';\r\nimport { mockContactCenterEntities, mockContactCenters } from './mock/cc-import.mock';\r\nimport {\r\n    ContactCenter,\r\n    ContactCenterCompatibilityStatus,\r\n    ContactCenterEntities,\r\n    ContactCenterEntityGroup,\r\n    ImportResult\r\n} from './types/cc-import';\r\nimport {\r\n    CALL_FLOW_MIGRATED,\r\n    CallFlowMigrationStatus,\r\n    UccxApplication,\r\n    UccxBatch,\r\n    UccxItem,\r\n    UccxItemsWrapper\r\n} from './types/uccx';\r\n\r\n/** Simulated network latency for the mock responses, so loading states are exercised. */\r\nconst MOCK_LATENCY_MS = 300;\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class CcImportService {\r\n    private readonly api = inject(APIService);\r\n    private readonly dcpApi = inject(DcpApiService);\r\n\r\n    /**\r\n     * Answer everything from `mock/cc-import.mock.ts` instead of calling the backend.\r\n     *\r\n     * Note this is all-or-nothing: with it off, the contact-center list, the entity\r\n     * overview and the import all hit real endpoints. Compatibility scoring is the\r\n     * exception - see {@link resolveCompatibility}.\r\n     */\r\n    useMockData = true;\r\n\r\n    setToken(token: string): void {\r\n        this.api.token = token;\r\n        this.dcpApi.token = token;\r\n    }\r\n\r\n    setHost(host: string): void {\r\n        this.api.apiUrl = host;\r\n    }\r\n\r\n    /** Base URL of the dcp host, which serves the UCCX application list. */\r\n    setDcpHost(dcpHost: string): void {\r\n        this.dcpApi.apiUrl = dcpHost;\r\n    }\r\n\r\n    /**\r\n     * Every UCCX contact center Tuki can import.\r\n     *\r\n     * A \"contact center\" is a UCCX application. The list comes from the dcp\r\n     * application cache; whether each one has already been imported is joined on from\r\n     * the per-AEF-script call-flow migration states.\r\n     */\r\n    fetchContactCenters(customerId: number): Observable<ContactCenter[]> {\r\n        if (this.useMockData) {\r\n            return of(mockContactCenters()).pipe(delay(MOCK_LATENCY_MS));\r\n        }\r\n\r\n        return forkJoin({\r\n            applications: this.dcpApi.fetch(API.UCCX.APPLICATION_NAMES(customerId)),\r\n            callFlows: this.api.fetch(API.UCCX.CALL_FLOW_MIGRATION_STATUSES(customerId))\r\n        }).pipe(\r\n            map(({ applications, callFlows }) => this.toContactCenters(\r\n                this.asArray<UccxApplication>(applications),\r\n                this.asArray<CallFlowMigrationStatus>(callFlows)\r\n            ))\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Application-centric entity breakdown: everything Tuki will create on import.\r\n     *\r\n     * Note this only ever returns entities the backend has actually linked to the\r\n     * application. Where that linkage is missing the groups come back empty rather\r\n     * than padded with unrelated entities of the right type.\r\n     */\r\n    fetchContactCenterEntities(customerId: number, contactCenter: ContactCenter): Observable<ContactCenterEntities> {\r\n        if (this.useMockData) {\r\n            return of(mockContactCenterEntities(contactCenter)).pipe(delay(MOCK_LATENCY_MS));\r\n        }\r\n\r\n        return this.fetchApplicationItems(customerId, contactCenter.applicationName).pipe(\r\n            map(items => ({\r\n                applicationId: contactCenter.applicationId,\r\n                groups: this.groupEntities(items)\r\n            }))\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Kicks off the UCCX -> Webex Contact Center import of one contact center, as a\r\n     * single migration unit: every entity of the application goes in one request.\r\n     *\r\n     * The endpoint is synchronous and answers with an XLSX tracker rather than a job\r\n     * id - execution and progress tracking are defined in a separate ticket.\r\n     *\r\n     * @param siteId     required by the backend when a Resource Group is in scope.\r\n     * @param locationId required by the backend when a Trigger is in scope.\r\n     */\r\n    importContactCenter(\r\n        customerId: number,\r\n        applicationId: string,\r\n        siteId?: string,\r\n        locationId?: string\r\n    ): Observable<ImportResult> {\r\n        if (this.useMockData) {\r\n            return of<ImportResult>({ applicationId, accepted: true }).pipe(delay(MOCK_LATENCY_MS));\r\n        }\r\n\r\n        return this.fetchApplicationItems(customerId, applicationId).pipe(\r\n            switchMap(items => {\r\n                const payload: UccxItemsWrapper = {\r\n                    uccxItemsList: items.length ? [items.map(item => ({ ...item, migrate: true }))] : []\r\n                };\r\n\r\n                return this.api.post(\r\n                    API.UCCX.MIGRATE(customerId),\r\n                    payload,\r\n                    { siteId, locationId },\r\n                    { responseType: 'blob' }\r\n                );\r\n            }),\r\n            map((report: Blob) => ({\r\n                applicationId,\r\n                accepted: true,\r\n                report: report instanceof Blob ? report : undefined\r\n            }))\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Every UCCX entity belonging to one application, gathered across the batches.\r\n     *\r\n     * UCCX batches hold one entity type each, so this reads them all and keeps the\r\n     * items whose `applicationName` matches. The narrowing is done here rather than\r\n     * through the endpoint's own `applicationName` param because that param answers\r\n     * `[]` on dev2 even for items that plainly carry the name.\r\n     */\r\n    private fetchApplicationItems(customerId: number, applicationName: string): Observable<UccxItem[]> {\r\n        return this.api.fetch(API.UCCX.BATCHES(customerId)).pipe(\r\n            switchMap(response => {\r\n                const batches = this.asArray<UccxBatch>(response);\r\n                if (!batches.length) {\r\n                    return of<UccxItem[]>([]);\r\n                }\r\n\r\n                return forkJoin(batches.map(batch =>\r\n                    this.api.fetch(API.UCCX.BATCH_ITEMS(customerId, batch.id))\r\n                        .pipe(map((wrapper: UccxItemsWrapper) => this.flattenItems(wrapper)))\r\n                )).pipe(map(perBatch => this.dedupeItems(\r\n                    perBatch.flat().filter(item => item.applicationName === applicationName)\r\n                )));\r\n            })\r\n        );\r\n    }\r\n\r\n    /** The items endpoint nests items one level; older responses come back flat. */\r\n    private flattenItems(wrapper: UccxItemsWrapper | null): UccxItem[] {\r\n        const items = wrapper?.uccxItemsList ?? [];\r\n        const flattened = Array.isArray(items[0])\r\n            ? (items as UccxItem[][]).flat()\r\n            : (items as unknown as UccxItem[]);\r\n        return flattened.filter(Boolean);\r\n    }\r\n\r\n    /** The same entity can be carried by more than one batch. */\r\n    private dedupeItems(items: UccxItem[]): UccxItem[] {\r\n        const seen = new Set<string>();\r\n        return items.filter(item => {\r\n            const key = `${item.type}::${item.name}::${item.sourceUCCXIp}`;\r\n            if (seen.has(key)) {\r\n                return false;\r\n            }\r\n            seen.add(key);\r\n            return true;\r\n        });\r\n    }\r\n\r\n    private groupEntities(items: UccxItem[]): ContactCenterEntityGroup[] {\r\n        const remaining = new Map<string, string[]>();\r\n        items.forEach(item => {\r\n            const names = remaining.get(item.type) ?? [];\r\n            names.push(item.name);\r\n            remaining.set(item.type, names);\r\n        });\r\n\r\n        const groups: ContactCenterEntityGroup[] = OVERVIEW_ENTITY_GROUPS.map(group => {\r\n            const collected: string[] = [];\r\n            group.types.forEach(type => {\r\n                collected.push(...(remaining.get(type) ?? []));\r\n                remaining.delete(type);\r\n            });\r\n            return { label: group.label, items: collected };\r\n        });\r\n\r\n        // Anything the backend returned that has no group of its own keeps its raw\r\n        // type as a label, rather than being dropped from the overview.\r\n        remaining.forEach((names, type) => groups.push({ label: type, items: names }));\r\n\r\n        return groups;\r\n    }\r\n\r\n    private toContactCenters(\r\n        applications: UccxApplication[],\r\n        callFlows: CallFlowMigrationStatus[]\r\n    ): ContactCenter[] {\r\n        return applications\r\n            .filter(application => !!application?.name)\r\n            .map(application => {\r\n                const uccxIp = application.uccx?.host;\r\n                const scriptName = this.toScriptName(application);\r\n                const compatibilityStatus = this.resolveCompatibility(application);\r\n\r\n                const contactCenter: ContactCenter = {\r\n                    // UCCX identifies an application by name - it is what the entity\r\n                    // records link back to - so it doubles as the widget's key.\r\n                    applicationId: application.name,\r\n                    applicationName: application.name,\r\n                    scriptName,\r\n                    uccxIp,\r\n                    compatibilityStatus,\r\n                    migrationState: this.resolveMigrationState(application, scriptName, uccxIp, callFlows),\r\n                    // Per the ticket, \"requires review\" is exactly the set that can go\r\n                    // to either destination.\r\n                    customerAssistCapable: compatibilityStatus === 'requires-review'\r\n                };\r\n\r\n                return contactCenter;\r\n            });\r\n    }\r\n\r\n    /** UCCX wraps the backing script as `SCRIPT[Foo.aef]`; the widget shows `Foo.aef`. */\r\n    private toScriptName(application: UccxApplication): string {\r\n        const raw = application.scriptName ?? application.aefFiles?.[0] ?? '';\r\n        return raw.replace(/^SCRIPT\\[(.*)\\]$/, '$1');\r\n    }\r\n\r\n    /**\r\n     * Whether Tuki has already imported this contact center.\r\n     *\r\n     * The application record carries its own `migrationStatus`, but it is null\r\n     * throughout dev2, so this falls back to the per-AEF-script call-flow state.\r\n     */\r\n    private resolveMigrationState(\r\n        application: UccxApplication,\r\n        scriptName: string,\r\n        uccxIp: string | undefined,\r\n        callFlows: CallFlowMigrationStatus[]\r\n    ): ContactCenter['migrationState'] {\r\n        if (application.migrationStatus) {\r\n            return application.migrationStatus === CALL_FLOW_MIGRATED ? 'migrated' : 'not-migrated';\r\n        }\r\n\r\n        const callFlow = callFlows.find(flow =>\r\n            flow.scriptName === scriptName && (!uccxIp || flow.uccxIp === uccxIp));\r\n\r\n        return callFlow?.status === CALL_FLOW_MIGRATED ? 'migrated' : 'not-migrated';\r\n    }\r\n\r\n    /**\r\n     * Turns an AEF compatibility score into a status.\r\n     *\r\n     * The scoring API does not exist yet - the AEF step mapping is still a pending\r\n     * input on the ticket - so when the backend sends no score every contact center\r\n     * falls back to \"requires review\": the status that offers both destinations and\r\n     * claims nothing about compatibility we have not actually measured.\r\n     *\r\n     * Once the backend returns `compatibilityScore`, the thresholds below take over\r\n     * with no further change here.\r\n     */\r\n    private resolveCompatibility(application: UccxApplication): ContactCenterCompatibilityStatus {\r\n        const score = (application as { compatibilityScore?: number }).compatibilityScore;\r\n\r\n        if (typeof score !== 'number') {\r\n            return 'requires-review';\r\n        }\r\n        if (score >= COMPATIBILITY_THRESHOLDS.migratable) {\r\n            return 'migratable';\r\n        }\r\n        if (score >= COMPATIBILITY_THRESHOLDS.requiresReview) {\r\n            return 'requires-review';\r\n        }\r\n        return 'unsupported';\r\n    }\r\n\r\n    private asArray<T>(value: unknown): T[] {\r\n        return Array.isArray(value) ? value as T[] : [];\r\n    }\r\n}\r\n"]}

package/esm2020/contact-center/cc-import/components/import-contact-center-panel/import-contact-center-panel.component.mjs

@@ -0,0 +1,144 @@
+import { Component, EventEmitter, Input, Output, inject } from '@angular/core';
+import { catchError, finalize, of } from 'rxjs';
+import { CcImportService } from '../../cc-import.service';
+import { CHART_COLORS, IMPORT_PANEL_SLICES, IMPORT_PANEL_TITLE, IMPORT_PANEL_TOOLTIP } from '../../constants/cc-import.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "ng-apexcharts";
+import * as i3 from "@angular/material/tooltip";
+import * as i4 from "../../../shared/components/card/card.component";
+/**
+ * "Import Contact center" panel: how many UCCX contact centers were detected, how many
+ * have been imported, and an Import button that asks the host to open the import wizard.
+ */
+export class ImportContactCenterPanelComponent {
+    constructor() {
+        /** Serve mock data instead of calling the UCCX migration API. */
+        this.useMockData = true;
+        /**
+         * Asked for the import wizard, carrying the contact centers already loaded here so
+         * the wizard opens without refetching them. The host renders
+         * `cc-import-contact-center-wizard` as a page in response.
+         */
+        this.importRequested = new EventEmitter();
+        this.ccImportService = inject(CcImportService);
+        this.title = IMPORT_PANEL_TITLE;
+        this.tooltip = IMPORT_PANEL_TOOLTIP;
+        this.segments = [];
+        this.total = 0;
+        this.loading = false;
+        this.error = false;
+        this.contactCenters = [];
+    }
+    ngOnInit() {
+        // Render an empty donut up front so the template never reads unset chart options,
+        // including when load() bails out because the widget has no credentials yet.
+        this.buildViewModel();
+        this.load();
+    }
+    ngOnChanges(changes) {
+        const reloadTriggers = ['customerId', 'host', 'dcpHost', 'token', 'useMockData'];
+        if (reloadTriggers.some(input => changes[input] && !changes[input].firstChange)) {
+            this.load();
+        }
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    onImport() {
+        this.importRequested.emit(this.contactCenters);
+    }
+    /** Call after an import has run so the donut picks up the new counts. */
+    refresh() {
+        this.load();
+    }
+    load() {
+        const customerId = Number(this.customerId);
+        this.ccImportService.useMockData = this.useMockData;
+        if (!this.useMockData && (!customerId || !this.token)) {
+            return;
+        }
+        if (this.host) {
+            this.ccImportService.setHost(this.host);
+        }
+        if (this.dcpHost) {
+            this.ccImportService.setDcpHost(this.dcpHost);
+        }
+        if (this.token) {
+            this.ccImportService.setToken(this.token);
+        }
+        this.subscription?.unsubscribe();
+        this.loading = true;
+        this.error = false;
+        this.subscription = this.ccImportService.fetchContactCenters(customerId)
+            .pipe(catchError(error => {
+            console.error('Unable to load the contact centers', error);
+            this.error = true;
+            return of([]);
+        }), finalize(() => this.loading = false))
+            .subscribe(contactCenters => {
+            this.contactCenters = contactCenters;
+            this.buildViewModel();
+        });
+    }
+    buildViewModel() {
+        this.total = this.contactCenters.length;
+        this.segments = IMPORT_PANEL_SLICES.map(slice => {
+            const count = this.contactCenters.filter(slice.match).length;
+            return {
+                label: slice.label,
+                color: slice.color,
+                tooltip: slice.tooltip,
+                count,
+                percentage: this.total > 0 ? Math.round((count / this.total) * 100) : 0
+            };
+        });
+        this.chartOptions = this.buildChartOptions();
+    }
+    buildChartOptions() {
+        const charted = this.segments.filter(segment => segment.count > 0);
+        const isEmpty = charted.length === 0;
+        return {
+            series: isEmpty ? [1] : charted.map(segment => segment.count),
+            labels: isEmpty ? ['No contact centers'] : charted.map(segment => segment.label),
+            colors: isEmpty ? [CHART_COLORS.webexContactCenter] : charted.map(segment => segment.color),
+            chart: {
+                type: 'donut',
+                height: 150,
+                width: 150,
+                sparkline: { enabled: true }
+            },
+            legend: { show: false },
+            plotOptions: {
+                pie: {
+                    expandOnClick: false,
+                    donut: { size: '72%' }
+                }
+            },
+            dataLabels: { enabled: false },
+            tooltip: { enabled: !isEmpty },
+            states: {
+                active: { filter: { type: 'none', value: 0 } }
+            }
+        };
+    }
+}
+ImportContactCenterPanelComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ImportContactCenterPanelComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ImportContactCenterPanelComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: ImportContactCenterPanelComponent, selector: "cc-import-contact-center-panel", inputs: { customerId: "customerId", host: "host", dcpHost: "dcpHost", token: "token", useMockData: "useMockData" }, outputs: { importRequested: "importRequested" }, usesOnChanges: true, ngImport: i0, template: "<tk-card [title]=\"title\" [dense]=\"true\">\r\n  <ng-container ngProjectAs=\"card-title-adornment\">\r\n    <span class=\"cc-import-panel__info\" [matTooltip]=\"tooltip\">\r\n      <ng-container *ngTemplateOutlet=\"infoIcon\"></ng-container>\r\n    </span>\r\n  </ng-container>\r\n\r\n  <ng-container ngProjectAs=\"card-content\">\r\n    <div class=\"cc-import-panel__body\" *ngIf=\"!loading && !error; else panelState\">\r\n      <div class=\"cc-import-panel__chart\">\r\n        <apx-chart\r\n          [series]=\"chartOptions.series\"\r\n          [chart]=\"chartOptions.chart\"\r\n          [labels]=\"chartOptions.labels\"\r\n          [colors]=\"chartOptions.colors\"\r\n          [legend]=\"chartOptions.legend\"\r\n          [plotOptions]=\"chartOptions.plotOptions\"\r\n          [dataLabels]=\"chartOptions.dataLabels\"\r\n          [tooltip]=\"chartOptions.tooltip\"\r\n          [states]=\"chartOptions.states\"\r\n        ></apx-chart>\r\n        <div class=\"cc-import-panel__chart-center\">\r\n          <span class=\"cc-import-panel__chart-total\">{{ total | number }}</span>\r\n          <span class=\"cc-import-panel__chart-caption\">Contact Center</span>\r\n        </div>\r\n      </div>\r\n\r\n      <ul class=\"cc-import-panel__legend\">\r\n        <li class=\"cc-import-panel__legend-item\" *ngFor=\"let segment of segments\">\r\n          <span class=\"cc-import-panel__legend-marker\" [style.backgroundColor]=\"segment.color\"></span>\r\n          <span class=\"cc-import-panel__legend-label\">{{ segment.label }}</span>\r\n          <span class=\"cc-import-panel__info\" [matTooltip]=\"segment.tooltip\">\r\n            <ng-container *ngTemplateOutlet=\"infoIcon\"></ng-container>\r\n          </span>\r\n          <span class=\"cc-import-panel__legend-value\">{{ segment.count | number }} ({{ segment.percentage }}%)</span>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n\r\n    <ng-template #panelState>\r\n      <div class=\"cc-import-panel__state\" *ngIf=\"loading\">Loading contact centers\u2026</div>\r\n      <div class=\"cc-import-panel__state cc-import-panel__state--error\" *ngIf=\"!loading && error\">\r\n        Unable to load contact centers.\r\n      </div>\r\n    </ng-template>\r\n\r\n    <div class=\"cc-import-panel__actions\">\r\n      <button\r\n        type=\"button\"\r\n        class=\"cc-import-panel__button\"\r\n        [disabled]=\"loading || error\"\r\n        (click)=\"onImport()\"\r\n      >\r\n        Import\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n</tk-card>\r\n\r\n<ng-template #infoIcon>\r\n  <svg width=\"14\" height=\"14\" viewBox=\"0 0 16 16\" fill=\"none\" aria-hidden=\"true\">\r\n    <circle cx=\"8\" cy=\"8\" r=\"6.5\" stroke=\"currentColor\" stroke-width=\"1.2\" />\r\n    <path d=\"M8 7.2v4\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\r\n    <circle cx=\"8\" cy=\"5\" r=\"0.85\" fill=\"currentColor\" />\r\n  </svg>\r\n</ng-template>\r\n", styles: ["@import\"https://fonts.googleapis.com/css?family=Poppins:400,100,200,300,500,600,800,700,900\";@import\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400&display=swap\";:host{display:block;box-sizing:border-box;font-family:Inter,Inter,sans-serif}.cc-import-panel__info{display:inline-flex;align-items:center;color:#636363;cursor:help}.cc-import-panel__body{display:flex;align-items:center;gap:1.5rem;flex-wrap:wrap;width:100%}.cc-import-panel__chart{position:relative;width:150px;height:150px;flex-shrink:0}.cc-import-panel__chart-center{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;pointer-events:none}.cc-import-panel__chart-total{font-size:1.625rem;line-height:1.1;color:#252525}.cc-import-panel__chart-caption{font-size:.6875rem;color:#636363}.cc-import-panel__legend{display:flex;flex-direction:column;gap:.625rem;margin:0;padding:0;list-style:none;min-width:17.5rem;flex:1}.cc-import-panel__legend-item{display:flex;align-items:center;gap:.5rem;font-size:.75rem;color:#636363}.cc-import-panel__legend-marker{width:10px;height:10px;border-radius:2px;flex-shrink:0}.cc-import-panel__legend-label{color:#252525}.cc-import-panel__legend-value{margin-left:auto;white-space:nowrap}.cc-import-panel__state{font-size:.875rem;color:#636363}.cc-import-panel__state--error{color:#bc1e1b}.cc-import-panel__actions{display:flex;margin-top:auto}.cc-import-panel__button{display:inline-flex;align-items:center;gap:.25rem;padding:.5rem 1rem;background:#fff;border:1px solid rgba(0,0,0,.5019607843);border-radius:6.25rem;font-family:inherit;font-size:.875rem;font-weight:500;color:#000000f2;cursor:pointer;white-space:nowrap}.cc-import-panel__button:hover:not(:disabled){background:#ededed}.cc-import-panel__button:disabled{color:#babcc5;border-color:#dfe3e7;cursor:not-allowed}@media (max-width: 560px){.cc-import-panel__legend{min-width:0}}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i2.ChartComponent, selector: "apx-chart", inputs: ["chart", "annotations", "colors", "dataLabels", "series", "stroke", "labels", "legend", "markers", "noData", "fill", "tooltip", "plotOptions", "responsive", "xaxis", "yaxis", "forecastDataPoints", "grid", "states", "title", "subtitle", "theme", "autoUpdateSeries"] }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "component", type: i4.CardComponent, selector: "tk-card", inputs: ["title", "dense"] }, { kind: "pipe", type: i1.DecimalPipe, name: "number" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ImportContactCenterPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cc-import-contact-center-panel', template: "<tk-card [title]=\"title\" [dense]=\"true\">\r\n  <ng-container ngProjectAs=\"card-title-adornment\">\r\n    <span class=\"cc-import-panel__info\" [matTooltip]=\"tooltip\">\r\n      <ng-container *ngTemplateOutlet=\"infoIcon\"></ng-container>\r\n    </span>\r\n  </ng-container>\r\n\r\n  <ng-container ngProjectAs=\"card-content\">\r\n    <div class=\"cc-import-panel__body\" *ngIf=\"!loading && !error; else panelState\">\r\n      <div class=\"cc-import-panel__chart\">\r\n        <apx-chart\r\n          [series]=\"chartOptions.series\"\r\n          [chart]=\"chartOptions.chart\"\r\n          [labels]=\"chartOptions.labels\"\r\n          [colors]=\"chartOptions.colors\"\r\n          [legend]=\"chartOptions.legend\"\r\n          [plotOptions]=\"chartOptions.plotOptions\"\r\n          [dataLabels]=\"chartOptions.dataLabels\"\r\n          [tooltip]=\"chartOptions.tooltip\"\r\n          [states]=\"chartOptions.states\"\r\n        ></apx-chart>\r\n        <div class=\"cc-import-panel__chart-center\">\r\n          <span class=\"cc-import-panel__chart-total\">{{ total | number }}</span>\r\n          <span class=\"cc-import-panel__chart-caption\">Contact Center</span>\r\n        </div>\r\n      </div>\r\n\r\n      <ul class=\"cc-import-panel__legend\">\r\n        <li class=\"cc-import-panel__legend-item\" *ngFor=\"let segment of segments\">\r\n          <span class=\"cc-import-panel__legend-marker\" [style.backgroundColor]=\"segment.color\"></span>\r\n          <span class=\"cc-import-panel__legend-label\">{{ segment.label }}</span>\r\n          <span class=\"cc-import-panel__info\" [matTooltip]=\"segment.tooltip\">\r\n            <ng-container *ngTemplateOutlet=\"infoIcon\"></ng-container>\r\n          </span>\r\n          <span class=\"cc-import-panel__legend-value\">{{ segment.count | number }} ({{ segment.percentage }}%)</span>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n\r\n    <ng-template #panelState>\r\n      <div class=\"cc-import-panel__state\" *ngIf=\"loading\">Loading contact centers\u2026</div>\r\n      <div class=\"cc-import-panel__state cc-import-panel__state--error\" *ngIf=\"!loading && error\">\r\n        Unable to load contact centers.\r\n      </div>\r\n    </ng-template>\r\n\r\n    <div class=\"cc-import-panel__actions\">\r\n      <button\r\n        type=\"button\"\r\n        class=\"cc-import-panel__button\"\r\n        [disabled]=\"loading || error\"\r\n        (click)=\"onImport()\"\r\n      >\r\n        Import\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n</tk-card>\r\n\r\n<ng-template #infoIcon>\r\n  <svg width=\"14\" height=\"14\" viewBox=\"0 0 16 16\" fill=\"none\" aria-hidden=\"true\">\r\n    <circle cx=\"8\" cy=\"8\" r=\"6.5\" stroke=\"currentColor\" stroke-width=\"1.2\" />\r\n    <path d=\"M8 7.2v4\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\r\n    <circle cx=\"8\" cy=\"5\" r=\"0.85\" fill=\"currentColor\" />\r\n  </svg>\r\n</ng-template>\r\n", styles: ["@import\"https://fonts.googleapis.com/css?family=Poppins:400,100,200,300,500,600,800,700,900\";@import\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400&display=swap\";:host{display:block;box-sizing:border-box;font-family:Inter,Inter,sans-serif}.cc-import-panel__info{display:inline-flex;align-items:center;color:#636363;cursor:help}.cc-import-panel__body{display:flex;align-items:center;gap:1.5rem;flex-wrap:wrap;width:100%}.cc-import-panel__chart{position:relative;width:150px;height:150px;flex-shrink:0}.cc-import-panel__chart-center{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;pointer-events:none}.cc-import-panel__chart-total{font-size:1.625rem;line-height:1.1;color:#252525}.cc-import-panel__chart-caption{font-size:.6875rem;color:#636363}.cc-import-panel__legend{display:flex;flex-direction:column;gap:.625rem;margin:0;padding:0;list-style:none;min-width:17.5rem;flex:1}.cc-import-panel__legend-item{display:flex;align-items:center;gap:.5rem;font-size:.75rem;color:#636363}.cc-import-panel__legend-marker{width:10px;height:10px;border-radius:2px;flex-shrink:0}.cc-import-panel__legend-label{color:#252525}.cc-import-panel__legend-value{margin-left:auto;white-space:nowrap}.cc-import-panel__state{font-size:.875rem;color:#636363}.cc-import-panel__state--error{color:#bc1e1b}.cc-import-panel__actions{display:flex;margin-top:auto}.cc-import-panel__button{display:inline-flex;align-items:center;gap:.25rem;padding:.5rem 1rem;background:#fff;border:1px solid rgba(0,0,0,.5019607843);border-radius:6.25rem;font-family:inherit;font-size:.875rem;font-weight:500;color:#000000f2;cursor:pointer;white-space:nowrap}.cc-import-panel__button:hover:not(:disabled){background:#ededed}.cc-import-panel__button:disabled{color:#babcc5;border-color:#dfe3e7;cursor:not-allowed}@media (max-width: 560px){.cc-import-panel__legend{min-width:0}}\n"] }]
+        }], propDecorators: { customerId: [{
+                type: Input
+            }], host: [{
+                type: Input
+            }], dcpHost: [{
+                type: Input
+            }], token: [{
+                type: Input
+            }], useMockData: [{
+                type: Input
+            }], importRequested: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import-contact-center-panel.component.js","sourceRoot":"","sources":["../../../../../../../../projects/tuki/widgets/contact-center/cc-import/components/import-contact-center-panel/import-contact-center-panel.component.ts","../../../../../../../../projects/tuki/widgets/contact-center/cc-import/components/import-contact-center-panel/import-contact-center-panel.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnChanges, OnDestroy, OnInit, Output, SimpleChanges, inject } from '@angular/core';\r\nimport { ApexChart, ApexDataLabels, ApexLegend, ApexNonAxisChartSeries, ApexPlotOptions, ApexStates, ApexTooltip } from 'ng-apexcharts';\r\nimport { Subscription, catchError, finalize, of } from 'rxjs';\r\nimport { CcImportService } from '../../cc-import.service';\r\nimport { CHART_COLORS, IMPORT_PANEL_SLICES, IMPORT_PANEL_TITLE, IMPORT_PANEL_TOOLTIP } from '../../constants/cc-import.constants';\r\nimport { ContactCenter, ImportPanelSegment } from '../../types/cc-import';\r\n\r\ninterface PanelChartOptions {\r\n    series: ApexNonAxisChartSeries;\r\n    chart: ApexChart;\r\n    labels: string[];\r\n    colors: string[];\r\n    legend: ApexLegend;\r\n    plotOptions: ApexPlotOptions;\r\n    dataLabels: ApexDataLabels;\r\n    tooltip: ApexTooltip;\r\n    states: ApexStates;\r\n}\r\n\r\n/**\r\n * \"Import Contact center\" panel: how many UCCX contact centers were detected, how many\r\n * have been imported, and an Import button that asks the host to open the import wizard.\r\n */\r\n@Component({\r\n    selector: 'cc-import-contact-center-panel',\r\n    templateUrl: './import-contact-center-panel.component.html',\r\n    styleUrls: ['./import-contact-center-panel.component.scss']\r\n})\r\nexport class ImportContactCenterPanelComponent implements OnInit, OnChanges, OnDestroy {\r\n    @Input() customerId!: number;\r\n    @Input() host!: string;\r\n    /** Base URL of the dcp host, which serves the UCCX application list. */\r\n    @Input() dcpHost!: string;\r\n    @Input() token!: string;\r\n    /** Serve mock data instead of calling the UCCX migration API. */\r\n    @Input() useMockData = true;\r\n\r\n    /**\r\n     * Asked for the import wizard, carrying the contact centers already loaded here so\r\n     * the wizard opens without refetching them. The host renders\r\n     * `cc-import-contact-center-wizard` as a page in response.\r\n     */\r\n    @Output() importRequested = new EventEmitter<ContactCenter[]>();\r\n\r\n    private readonly ccImportService = inject(CcImportService);\r\n    private subscription?: Subscription;\r\n\r\n    readonly title = IMPORT_PANEL_TITLE;\r\n    readonly tooltip = IMPORT_PANEL_TOOLTIP;\r\n\r\n    segments: ImportPanelSegment[] = [];\r\n    chartOptions!: PanelChartOptions;\r\n    total = 0;\r\n    loading = false;\r\n    error = false;\r\n\r\n    private contactCenters: ContactCenter[] = [];\r\n\r\n    ngOnInit(): void {\r\n        // Render an empty donut up front so the template never reads unset chart options,\r\n        // including when load() bails out because the widget has no credentials yet.\r\n        this.buildViewModel();\r\n        this.load();\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        const reloadTriggers = ['customerId', 'host', 'dcpHost', 'token', 'useMockData'];\r\n        if (reloadTriggers.some(input => changes[input] && !changes[input].firstChange)) {\r\n            this.load();\r\n        }\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.subscription?.unsubscribe();\r\n    }\r\n\r\n    onImport(): void {\r\n        this.importRequested.emit(this.contactCenters);\r\n    }\r\n\r\n    /** Call after an import has run so the donut picks up the new counts. */\r\n    refresh(): void {\r\n        this.load();\r\n    }\r\n\r\n    private load(): void {\r\n        const customerId = Number(this.customerId);\r\n        this.ccImportService.useMockData = this.useMockData;\r\n\r\n        if (!this.useMockData && (!customerId || !this.token)) {\r\n            return;\r\n        }\r\n\r\n        if (this.host) {\r\n            this.ccImportService.setHost(this.host);\r\n        }\r\n        if (this.dcpHost) {\r\n            this.ccImportService.setDcpHost(this.dcpHost);\r\n        }\r\n        if (this.token) {\r\n            this.ccImportService.setToken(this.token);\r\n        }\r\n\r\n        this.subscription?.unsubscribe();\r\n        this.loading = true;\r\n        this.error = false;\r\n\r\n        this.subscription = this.ccImportService.fetchContactCenters(customerId)\r\n            .pipe(\r\n                catchError(error => {\r\n                    console.error('Unable to load the contact centers', error);\r\n                    this.error = true;\r\n                    return of<ContactCenter[]>([]);\r\n                }),\r\n                finalize(() => this.loading = false)\r\n            )\r\n            .subscribe(contactCenters => {\r\n                this.contactCenters = contactCenters;\r\n                this.buildViewModel();\r\n            });\r\n    }\r\n\r\n    private buildViewModel(): void {\r\n        this.total = this.contactCenters.length;\r\n\r\n        this.segments = IMPORT_PANEL_SLICES.map(slice => {\r\n            const count = this.contactCenters.filter(slice.match).length;\r\n            return {\r\n                label: slice.label,\r\n                color: slice.color,\r\n                tooltip: slice.tooltip,\r\n                count,\r\n                percentage: this.total > 0 ? Math.round((count / this.total) * 100) : 0\r\n            };\r\n        });\r\n\r\n        this.chartOptions = this.buildChartOptions();\r\n    }\r\n\r\n    private buildChartOptions(): PanelChartOptions {\r\n        const charted = this.segments.filter(segment => segment.count > 0);\r\n        const isEmpty = charted.length === 0;\r\n\r\n        return {\r\n            series: isEmpty ? [1] : charted.map(segment => segment.count),\r\n            labels: isEmpty ? ['No contact centers'] : charted.map(segment => segment.label),\r\n            colors: isEmpty ? [CHART_COLORS.webexContactCenter] : charted.map(segment => segment.color),\r\n            chart: {\r\n                type: 'donut',\r\n                height: 150,\r\n                width: 150,\r\n                sparkline: { enabled: true }\r\n            },\r\n            legend: { show: false },\r\n            plotOptions: {\r\n                pie: {\r\n                    expandOnClick: false,\r\n                    donut: { size: '72%' }\r\n                }\r\n            },\r\n            dataLabels: { enabled: false },\r\n            tooltip: { enabled: !isEmpty },\r\n            states: {\r\n                active: { filter: { type: 'none', value: 0 } }\r\n            }\r\n        };\r\n    }\r\n}\r\n","<tk-card [title]=\"title\" [dense]=\"true\">\r\n  <ng-container ngProjectAs=\"card-title-adornment\">\r\n    <span class=\"cc-import-panel__info\" [matTooltip]=\"tooltip\">\r\n      <ng-container *ngTemplateOutlet=\"infoIcon\"></ng-container>\r\n    </span>\r\n  </ng-container>\r\n\r\n  <ng-container ngProjectAs=\"card-content\">\r\n    <div class=\"cc-import-panel__body\" *ngIf=\"!loading && !error; else panelState\">\r\n      <div class=\"cc-import-panel__chart\">\r\n        <apx-chart\r\n          [series]=\"chartOptions.series\"\r\n          [chart]=\"chartOptions.chart\"\r\n          [labels]=\"chartOptions.labels\"\r\n          [colors]=\"chartOptions.colors\"\r\n          [legend]=\"chartOptions.legend\"\r\n          [plotOptions]=\"chartOptions.plotOptions\"\r\n          [dataLabels]=\"chartOptions.dataLabels\"\r\n          [tooltip]=\"chartOptions.tooltip\"\r\n          [states]=\"chartOptions.states\"\r\n        ></apx-chart>\r\n        <div class=\"cc-import-panel__chart-center\">\r\n          <span class=\"cc-import-panel__chart-total\">{{ total | number }}</span>\r\n          <span class=\"cc-import-panel__chart-caption\">Contact Center</span>\r\n        </div>\r\n      </div>\r\n\r\n      <ul class=\"cc-import-panel__legend\">\r\n        <li class=\"cc-import-panel__legend-item\" *ngFor=\"let segment of segments\">\r\n          <span class=\"cc-import-panel__legend-marker\" [style.backgroundColor]=\"segment.color\"></span>\r\n          <span class=\"cc-import-panel__legend-label\">{{ segment.label }}</span>\r\n          <span class=\"cc-import-panel__info\" [matTooltip]=\"segment.tooltip\">\r\n            <ng-container *ngTemplateOutlet=\"infoIcon\"></ng-container>\r\n          </span>\r\n          <span class=\"cc-import-panel__legend-value\">{{ segment.count | number }} ({{ segment.percentage }}%)</span>\r\n        </li>\r\n      </ul>\r\n    </div>\r\n\r\n    <ng-template #panelState>\r\n      <div class=\"cc-import-panel__state\" *ngIf=\"loading\">Loading contact centers…</div>\r\n      <div class=\"cc-import-panel__state cc-import-panel__state--error\" *ngIf=\"!loading && error\">\r\n        Unable to load contact centers.\r\n      </div>\r\n    </ng-template>\r\n\r\n    <div class=\"cc-import-panel__actions\">\r\n      <button\r\n        type=\"button\"\r\n        class=\"cc-import-panel__button\"\r\n        [disabled]=\"loading || error\"\r\n        (click)=\"onImport()\"\r\n      >\r\n        Import\r\n      </button>\r\n    </div>\r\n  </ng-container>\r\n</tk-card>\r\n\r\n<ng-template #infoIcon>\r\n  <svg width=\"14\" height=\"14\" viewBox=\"0 0 16 16\" fill=\"none\" aria-hidden=\"true\">\r\n    <circle cx=\"8\" cy=\"8\" r=\"6.5\" stroke=\"currentColor\" stroke-width=\"1.2\" />\r\n    <path d=\"M8 7.2v4\" stroke=\"currentColor\" stroke-width=\"1.4\" stroke-linecap=\"round\" />\r\n    <circle cx=\"8\" cy=\"5\" r=\"0.85\" fill=\"currentColor\" />\r\n  </svg>\r\n</ng-template>\r\n"]}