@tuki-io/tuki-widgets 0.0.219-dev.6 → 0.0.219-dev.62

package/esm2020/workspaces/src/services/workspace-detail.service.mjs

@@ -0,0 +1,169 @@
+import { Injectable } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { API } from '../app.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+import * as i2 from "./api-webex.service";
+export class WorkspaceDetailService {
+    constructor(apiService, apiWebexService) {
+        this.apiService = apiService;
+        this.apiWebexService = apiWebexService;
+    }
+    getByWorkspace(workspace, connectionType, customerId) {
+        if (connectionType === 'webex' && workspace.device.webexUUID) {
+            return this.getWebexDetails(customerId, workspace.device.webexUUID);
+        }
+        return this.getCucmDetails(workspace);
+    }
+    getWebexDetails(customerId, workspaceId) {
+        const params = { customerId: String(customerId), workspaceId };
+        return forkJoin([
+            this.apiWebexService.fetch(this.buildUrl(API.DETAILS.WEBEX.WORKSPACE, params)),
+            this.apiWebexService.fetch(this.buildUrl(API.DETAILS.WEBEX.NUMBERS, params)),
+            this.apiWebexService.fetch(this.buildUrl(API.DETAILS.WEBEX.CALLERID, params)),
+        ]).pipe(map(([workspaceRes, numbersRes, callerIdRes]) => this.toWebexDetails(workspaceRes, numbersRes, callerIdRes)));
+    }
+    toWebexDetails(workspaceRes, numbersRes, callerIdRes) {
+        const primaryNumber = numbersRes.phoneNumbers?.find(number => number.primary) ?? numbersRes.phoneNumbers?.[0];
+        return {
+            issues: this.buildIssues(workspaceRes.type, workspaceRes.capacity),
+            location: {
+                country: numbersRes.location?.name || workspaceRes.locationName || 'Not set',
+                address: numbersRes.location?.address || 'Address not available',
+            },
+            calling: {
+                license: workspaceRes.licenseName || 'Not set',
+                sipAddress: workspaceRes.sipAddress || 'Not assigned',
+                directoryNumber: primaryNumber?.external || primaryNumber?.extension || 'Not assigned',
+                extension: primaryNumber?.extension || undefined,
+                routePartition: '',
+                callingSearchSpace: '',
+                securityProfile: '',
+                externalCallerIdName: callerIdRes.locationExternalCallerIdName || callerIdRes.customExternalCallerIdName || undefined,
+                externalCallerIdNumber: callerIdRes.locationNumber || callerIdRes.customNumber || callerIdRes.directNumber || undefined,
+            },
+            schedulingConfigured: false,
+            plannedMaintenanceEnabled: false,
+            notes: null,
+            capacity: workspaceRes.capacity,
+            device: this.buildWebexDeviceDetails(workspaceRes, numbersRes),
+        };
+    }
+    buildWebexDeviceDetails(workspaceRes, numbersRes) {
+        const device = workspaceRes.devices?.[0];
+        const primaryNumber = numbersRes.phoneNumbers?.find(number => number.primary) ?? numbersRes.phoneNumbers?.[0];
+        return {
+            model: device?.model || 'Unknown device',
+            registrationStatus: device?.registered ? 'Registered' : 'Not Registered',
+            mac: device?.mac || 'N/A',
+            lineCount: numbersRes.phoneNumbers?.length ?? null,
+            hostIpAddress: 'N/A',
+            remoteIpAddress: 'N/A',
+            managedBy: 'Cisco',
+            softwareChannel: 'Unknown',
+            softwareVersion: 'N/A',
+            lines: primaryNumber ? [{
+                    name: workspaceRes.workspaceName || '',
+                    number: primaryNumber.external || primaryNumber.extension || 'NA',
+                    registered: !!device?.registered,
+                }] : [],
+        };
+    }
+    getCucmDetails(workspace) {
+        const siteId = String(workspace.siteId);
+        const params = { siteId, workspaceId: workspace.cucmDeviceName ?? workspace.device.name };
+        return forkJoin([
+            this.apiService.fetch(this.buildUrl(API.DETAILS.CUCM.WORKSPACE, params)),
+            this.apiService.fetch(this.buildUrl(API.DETAILS.CUCM.SITE, { siteId })),
+        ]).pipe(map(([workspaceRes, siteRes]) => this.toCucmDetails(workspace, workspaceRes, siteRes)));
+    }
+    toCucmDetails(workspace, workspaceRes, siteRes) {
+        const device = workspaceRes.device;
+        const directoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';
+        const sipAddress = `${(device.name || workspace.displayName || 'workspace').toLowerCase()}@tukidev.rooms.webex.com`;
+        const address = [siteRes.address2, siteRes.address3].filter(Boolean).join(', ');
+        return {
+            issues: this.buildIssues(workspace.typeLabel, workspace.capacity),
+            location: {
+                country: siteRes.country || 'Not set',
+                address: address || 'Address not available',
+            },
+            calling: {
+                license: workspace.callingLicense || 'Cisco Webex Calling Professional Workspace',
+                sipAddress,
+                directoryNumber: directoryNumber || 'Not assigned',
+                routePartition: device.associatedDNs?.[0]?.routePartitionName || 'Not set',
+                callingSearchSpace: device.callingSearchSpaceName || 'Not set',
+                securityProfile: device.securityProfile || 'Not set',
+            },
+            schedulingConfigured: false,
+            plannedMaintenanceEnabled: false,
+            notes: null,
+            device: this.buildCucmDeviceDetails(workspaceRes),
+        };
+    }
+    buildCucmDeviceDetails(workspaceRes) {
+        const device = workspaceRes.device;
+        const isRegistered = (device.deviceRegStatus || '').toLowerCase() === 'registered';
+        return {
+            model: device.deviceType || 'Unknown device',
+            registrationStatus: device.deviceRegStatus || 'Not Registered',
+            mac: workspaceRes.workspaceDevices?.[0]?.mac || 'N/A',
+            lineCount: workspaceRes.lines?.length ?? null,
+            hostIpAddress: device.ipAddress || 'N/A',
+            remoteIpAddress: 'N/A',
+            managedBy: 'Cisco',
+            softwareChannel: 'Unknown',
+            softwareVersion: device.firmwareVersion || 'N/A',
+            lines: (workspaceRes.lines || []).map(line => ({
+                name: line.alertingName || line.description || '',
+                number: line.directoryNumber?.directoryNumber || 'NA',
+                registered: isRegistered,
+            })),
+        };
+    }
+    buildUrl(template, params) {
+        return Object.keys(params).reduce((url, key) => url.replace(`:${key}`, params[key]), template);
+    }
+    buildIssues(typeLabel, capacity) {
+        const timestamp = this.formatTimestamp(new Date());
+        return [
+            !typeLabel || typeLabel === 'No type' || typeLabel.toLowerCase() === 'notset' ? {
+                id: 'type',
+                message: 'Workspace type not set',
+                timestamp,
+                actionLabel: 'Assign type',
+                description: 'Adding a type specifies what the workspace is used for.',
+                suggestedAction: 'Set a type for this workspace.',
+            } : null,
+            capacity == null ? {
+                id: 'capacity',
+                message: 'Workspace capacity not set',
+                timestamp,
+                actionLabel: 'Set capacity',
+                description: 'Adding a capacity specifies how many people can use this workspace.',
+                suggestedAction: 'Set a capacity for this workspace.',
+            } : null,
+        ].filter((issue) => issue !== null);
+    }
+    formatTimestamp(date) {
+        return date.toLocaleString('en-US', {
+            year: '2-digit',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: '2-digit',
+            hour12: true,
+        });
+    }
+}
+WorkspaceDetailService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspaceDetailService, deps: [{ token: i1.APIService }, { token: i2.ApiWebexService }], target: i0.ɵɵFactoryTarget.Injectable });
+WorkspaceDetailService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspaceDetailService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspaceDetailService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.APIService }, { type: i2.ApiWebexService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-detail.service.js","sourceRoot":"","sources":["../../../../../../../projects/tuki/widgets/workspaces/src/services/workspace-detail.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAc,MAAM,MAAM,CAAC;AAC5C,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;;;;AAmBvC,MAAM,OAAO,sBAAsB;IACjC,YACU,UAAsB,EACtB,eAAgC;QADhC,eAAU,GAAV,UAAU,CAAY;QACtB,oBAAe,GAAf,eAAe,CAAiB;IACtC,CAAC;IAEL,cAAc,CACZ,SAAoB,EACpB,cAAuC,EACvC,UAA2B;QAE3B,IAAI,cAAc,KAAK,OAAO,IAAI,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE;YAC5D,OAAO,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;SACrE;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAEO,eAAe,CAAC,UAA2B,EAAE,WAAmB;QACtE,MAAM,MAAM,GAAG,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,EAAE,WAAW,EAAE,CAAC;QAE/D,OAAO,QAAQ,CAAC;YACd,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YAC9E,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAC5E,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;SAC9E,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,CAAC,CAAC,YAAY,EAAE,UAAU,EAAE,WAAW,CAI1C,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC,CAClE,CAAC;IACJ,CAAC;IAEO,cAAc,CACpB,YAA2C,EAC3C,UAAgC,EAChC,WAAkC;QAElC,MAAM,aAAa,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC;QAE9G,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;YAClE,QAAQ,EAAE;gBACR,OAAO,EAAE,UAAU,CAAC,QAAQ,EAAE,IAAI,IAAI,YAAY,CAAC,YAAY,IAAI,SAAS;gBAC5E,OAAO,EAAE,UAAU,CAAC,QAAQ,EAAE,OAAO,IAAI,uBAAuB;aACjE;YACD,OAAO,EAAE;gBACP,OAAO,EAAE,YAAY,CAAC,WAAW,IAAI,SAAS;gBAC9C,UAAU,EAAE,YAAY,CAAC,UAAU,IAAI,cAAc;gBACrD,eAAe,EAAE,aAAa,EAAE,QAAQ,IAAI,aAAa,EAAE,SAAS,IAAI,cAAc;gBACtF,SAAS,EAAE,aAAa,EAAE,SAAS,IAAI,SAAS;gBAChD,cAAc,EAAE,EAAE;gBAClB,kBAAkB,EAAE,EAAE;gBACtB,eAAe,EAAE,EAAE;gBACnB,oBAAoB,EAAE,WAAW,CAAC,4BAA4B,IAAI,WAAW,CAAC,0BAA0B,IAAI,SAAS;gBACrH,sBAAsB,EAAE,WAAW,CAAC,cAAc,IAAI,WAAW,CAAC,YAAY,IAAI,WAAW,CAAC,YAAY,IAAI,SAAS;aACxH;YACD,oBAAoB,EAAE,KAAK;YAC3B,yBAAyB,EAAE,KAAK;YAChC,KAAK,EAAE,IAAI;YACX,QAAQ,EAAE,YAAY,CAAC,QAAQ;YAC/B,MAAM,EAAE,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,UAAU,CAAC;SAC/D,CAAC;IACJ,CAAC;IAEO,uBAAuB,CAC7B,YAA2C,EAC3C,UAAgC;QAEhC,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;QACzC,MAAM,aAAa,GAAG,UAAU,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,CAAC;QAE9G,OAAO;YACL,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,gBAAgB;YACxC,kBAAkB,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB;YACxE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,KAAK;YACzB,SAAS,EAAE,UAAU,CAAC,YAAY,EAAE,MAAM,IAAI,IAAI;YAClD,aAAa,EAAE,KAAK;YACpB,eAAe,EAAE,KAAK;YACtB,SAAS,EAAE,OAAO;YAClB,eAAe,EAAE,SAAS;YAC1B,eAAe,EAAE,KAAK;YACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;oBACtB,IAAI,EAAE,YAAY,CAAC,aAAa,IAAI,EAAE;oBACtC,MAAM,EAAE,aAAa,CAAC,QAAQ,IAAI,aAAa,CAAC,SAAS,IAAI,IAAI;oBACjE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,UAAU;iBACjC,CAAC,CAAC,CAAC,CAAC,EAAE;SACR,CAAC;IACJ,CAAC;IAEO,cAAc,CAAC,SAAoB;QACzC,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAE1F,OAAO,QAAQ,CAAC;YACd,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACxE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;SACxE,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,CAAC,CAAC,YAAY,EAAE,OAAO,CAAmD,EAAE,EAAE,CAChF,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC,CACxD,CAAC;IACJ,CAAC;IAEO,aAAa,CACnB,SAAoB,EACpB,YAA0C,EAC1C,OAAyB;QAEzB,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;QACnC,MAAM,eAAe,GAAG,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,eAAe,IAAI,EAAE,CAAC;QACzE,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,SAAS,CAAC,WAAW,IAAI,WAAW,CAAC,CAAC,WAAW,EAAE,0BAA0B,CAAC;QACpH,MAAM,OAAO,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhF,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;YACjE,QAAQ,EAAE;gBACR,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,SAAS;gBACrC,OAAO,EAAE,OAAO,IAAI,uBAAuB;aAC5C;YACD,OAAO,EAAE;gBACP,OAAO,EAAE,SAAS,CAAC,cAAc,IAAI,4CAA4C;gBACjF,UAAU;gBACV,eAAe,EAAE,eAAe,IAAI,cAAc;gBAClD,cAAc,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,kBAAkB,IAAI,SAAS;gBAC1E,kBAAkB,EAAE,MAAM,CAAC,sBAAsB,IAAI,SAAS;gBAC9D,eAAe,EAAE,MAAM,CAAC,eAAe,IAAI,SAAS;aACrD;YACD,oBAAoB,EAAE,KAAK;YAC3B,yBAAyB,EAAE,KAAK;YAChC,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC;SAClD,CAAC;IACJ,CAAC;IAEO,sBAAsB,CAAC,YAA0C;QACvE,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;QACnC,MAAM,YAAY,GAAG,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,KAAK,YAAY,CAAC;QAEnF,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,UAAU,IAAI,gBAAgB;YAC5C,kBAAkB,EAAE,MAAM,CAAC,eAAe,IAAI,gBAAgB;YAC9D,GAAG,EAAE,YAAY,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,KAAK;YACrD,SAAS,EAAE,YAAY,CAAC,KAAK,EAAE,MAAM,IAAI,IAAI;YAC7C,aAAa,EAAE,MAAM,CAAC,SAAS,IAAI,KAAK;YACxC,eAAe,EAAE,KAAK;YACtB,SAAS,EAAE,OAAO;YAClB,eAAe,EAAE,SAAS;YAC1B,eAAe,EAAE,MAAM,CAAC,eAAe,IAAI,KAAK;YAChD,KAAK,EAAE,CAAC,YAAY,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC7C,IAAI,EAAE,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,WAAW,IAAI,EAAE;gBACjD,MAAM,EAAE,IAAI,CAAC,eAAe,EAAE,eAAe,IAAI,IAAI;gBACrD,UAAU,EAAE,YAAY;aACzB,CAAC,CAAC;SACJ,CAAC;IACJ,CAAC;IAEO,QAAQ,CAAC,QAAgB,EAAE,MAA8B;QAC/D,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IACjG,CAAC;IAEO,WAAW,CAAC,SAAoC,EAAE,QAAmC;QAC3F,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QAEnD,OAAO;YACL,CAAC,SAAS,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,WAAW,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC;gBAC9E,EAAE,EAAE,MAAM;gBACV,OAAO,EAAE,wBAAwB;gBACjC,SAAS;gBACT,WAAW,EAAE,aAAa;gBAC1B,WAAW,EAAE,yDAAyD;gBACtE,eAAe,EAAE,gCAAgC;aAClD,CAAC,CAAC,CAAC,IAAI;YACR,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC;gBACjB,EAAE,EAAE,UAAU;gBACd,OAAO,EAAE,4BAA4B;gBACrC,SAAS;gBACT,WAAW,EAAE,cAAc;gBAC3B,WAAW,EAAE,qEAAqE;gBAClF,eAAe,EAAE,oCAAoC;aACtD,CAAC,CAAC,CAAC,IAAI;SACT,CAAC,MAAM,CAAC,CAAC,KAAK,EAAsC,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IAC1E,CAAC;IAEO,eAAe,CAAC,IAAU;QAChC,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE;YAClC,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,SAAS;YAChB,GAAG,EAAE,SAAS;YACd,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,SAAS;YACjB,MAAM,EAAE,IAAI;SACb,CAAC,CAAC;IACL,CAAC;;oHAhMU,sBAAsB;wHAAtB,sBAAsB,cAFrB,MAAM;4FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { forkJoin, Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { API } from '../app.constants';\r\nimport { ApiWebexService } from './api-webex.service';\r\nimport { APIService } from './api.service';\r\nimport {\r\n  CucmSiteResponse,\r\n  CucmWorkspaceDetailsResponse,\r\n  WebexCallerIdResponse,\r\n  WebexNumbersResponse,\r\n  WebexWorkspaceDetailsResponse,\r\n  Workspace,\r\n  WorkspaceConnectionType,\r\n  WorkspaceDetails,\r\n  WorkspaceDeviceDetails,\r\n  WorkspaceIssue,\r\n} from '../types/workspace';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WorkspaceDetailService {\r\n  constructor(\r\n    private apiService: APIService,\r\n    private apiWebexService: ApiWebexService,\r\n  ) { }\r\n\r\n  getByWorkspace(\r\n    workspace: Workspace,\r\n    connectionType: WorkspaceConnectionType,\r\n    customerId: string | number,\r\n  ): Observable<WorkspaceDetails> {\r\n    if (connectionType === 'webex' && workspace.device.webexUUID) {\r\n      return this.getWebexDetails(customerId, workspace.device.webexUUID);\r\n    }\r\n    return this.getCucmDetails(workspace);\r\n  }\r\n\r\n  private getWebexDetails(customerId: string | number, workspaceId: string): Observable<WorkspaceDetails> {\r\n    const params = { customerId: String(customerId), workspaceId };\r\n\r\n    return forkJoin([\r\n      this.apiWebexService.fetch(this.buildUrl(API.DETAILS.WEBEX.WORKSPACE, params)),\r\n      this.apiWebexService.fetch(this.buildUrl(API.DETAILS.WEBEX.NUMBERS, params)),\r\n      this.apiWebexService.fetch(this.buildUrl(API.DETAILS.WEBEX.CALLERID, params)),\r\n    ]).pipe(\r\n      map(([workspaceRes, numbersRes, callerIdRes]: [\r\n        WebexWorkspaceDetailsResponse,\r\n        WebexNumbersResponse,\r\n        WebexCallerIdResponse,\r\n      ]) => this.toWebexDetails(workspaceRes, numbersRes, callerIdRes)),\r\n    );\r\n  }\r\n\r\n  private toWebexDetails(\r\n    workspaceRes: WebexWorkspaceDetailsResponse,\r\n    numbersRes: WebexNumbersResponse,\r\n    callerIdRes: WebexCallerIdResponse,\r\n  ): WorkspaceDetails {\r\n    const primaryNumber = numbersRes.phoneNumbers?.find(number => number.primary) ?? numbersRes.phoneNumbers?.[0];\r\n\r\n    return {\r\n      issues: this.buildIssues(workspaceRes.type, workspaceRes.capacity),\r\n      location: {\r\n        country: numbersRes.location?.name || workspaceRes.locationName || 'Not set',\r\n        address: numbersRes.location?.address || 'Address not available',\r\n      },\r\n      calling: {\r\n        license: workspaceRes.licenseName || 'Not set',\r\n        sipAddress: workspaceRes.sipAddress || 'Not assigned',\r\n        directoryNumber: primaryNumber?.external || primaryNumber?.extension || 'Not assigned',\r\n        extension: primaryNumber?.extension || undefined,\r\n        routePartition: '',\r\n        callingSearchSpace: '',\r\n        securityProfile: '',\r\n        externalCallerIdName: callerIdRes.locationExternalCallerIdName || callerIdRes.customExternalCallerIdName || undefined,\r\n        externalCallerIdNumber: callerIdRes.locationNumber || callerIdRes.customNumber || callerIdRes.directNumber || undefined,\r\n      },\r\n      schedulingConfigured: false,\r\n      plannedMaintenanceEnabled: false,\r\n      notes: null,\r\n      capacity: workspaceRes.capacity,\r\n      device: this.buildWebexDeviceDetails(workspaceRes, numbersRes),\r\n    };\r\n  }\r\n\r\n  private buildWebexDeviceDetails(\r\n    workspaceRes: WebexWorkspaceDetailsResponse,\r\n    numbersRes: WebexNumbersResponse,\r\n  ): WorkspaceDeviceDetails {\r\n    const device = workspaceRes.devices?.[0];\r\n    const primaryNumber = numbersRes.phoneNumbers?.find(number => number.primary) ?? numbersRes.phoneNumbers?.[0];\r\n\r\n    return {\r\n      model: device?.model || 'Unknown device',\r\n      registrationStatus: device?.registered ? 'Registered' : 'Not Registered',\r\n      mac: device?.mac || 'N/A',\r\n      lineCount: numbersRes.phoneNumbers?.length ?? null,\r\n      hostIpAddress: 'N/A',\r\n      remoteIpAddress: 'N/A',\r\n      managedBy: 'Cisco',\r\n      softwareChannel: 'Unknown',\r\n      softwareVersion: 'N/A',\r\n      lines: primaryNumber ? [{\r\n        name: workspaceRes.workspaceName || '',\r\n        number: primaryNumber.external || primaryNumber.extension || 'NA',\r\n        registered: !!device?.registered,\r\n      }] : [],\r\n    };\r\n  }\r\n\r\n  private getCucmDetails(workspace: Workspace): Observable<WorkspaceDetails> {\r\n    const siteId = String(workspace.siteId);\r\n    const params = { siteId, workspaceId: workspace.cucmDeviceName ?? workspace.device.name };\r\n\r\n    return forkJoin([\r\n      this.apiService.fetch(this.buildUrl(API.DETAILS.CUCM.WORKSPACE, params)),\r\n      this.apiService.fetch(this.buildUrl(API.DETAILS.CUCM.SITE, { siteId })),\r\n    ]).pipe(\r\n      map(([workspaceRes, siteRes]: [CucmWorkspaceDetailsResponse, CucmSiteResponse]) =>\r\n        this.toCucmDetails(workspace, workspaceRes, siteRes)),\r\n    );\r\n  }\r\n\r\n  private toCucmDetails(\r\n    workspace: Workspace,\r\n    workspaceRes: CucmWorkspaceDetailsResponse,\r\n    siteRes: CucmSiteResponse,\r\n  ): WorkspaceDetails {\r\n    const device = workspaceRes.device;\r\n    const directoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';\r\n    const sipAddress = `${(device.name || workspace.displayName || 'workspace').toLowerCase()}@tukidev.rooms.webex.com`;\r\n    const address = [siteRes.address2, siteRes.address3].filter(Boolean).join(', ');\r\n\r\n    return {\r\n      issues: this.buildIssues(workspace.typeLabel, workspace.capacity),\r\n      location: {\r\n        country: siteRes.country || 'Not set',\r\n        address: address || 'Address not available',\r\n      },\r\n      calling: {\r\n        license: workspace.callingLicense || 'Cisco Webex Calling Professional Workspace',\r\n        sipAddress,\r\n        directoryNumber: directoryNumber || 'Not assigned',\r\n        routePartition: device.associatedDNs?.[0]?.routePartitionName || 'Not set',\r\n        callingSearchSpace: device.callingSearchSpaceName || 'Not set',\r\n        securityProfile: device.securityProfile || 'Not set',\r\n      },\r\n      schedulingConfigured: false,\r\n      plannedMaintenanceEnabled: false,\r\n      notes: null,\r\n      device: this.buildCucmDeviceDetails(workspaceRes),\r\n    };\r\n  }\r\n\r\n  private buildCucmDeviceDetails(workspaceRes: CucmWorkspaceDetailsResponse): WorkspaceDeviceDetails {\r\n    const device = workspaceRes.device;\r\n    const isRegistered = (device.deviceRegStatus || '').toLowerCase() === 'registered';\r\n\r\n    return {\r\n      model: device.deviceType || 'Unknown device',\r\n      registrationStatus: device.deviceRegStatus || 'Not Registered',\r\n      mac: workspaceRes.workspaceDevices?.[0]?.mac || 'N/A',\r\n      lineCount: workspaceRes.lines?.length ?? null,\r\n      hostIpAddress: device.ipAddress || 'N/A',\r\n      remoteIpAddress: 'N/A',\r\n      managedBy: 'Cisco',\r\n      softwareChannel: 'Unknown',\r\n      softwareVersion: device.firmwareVersion || 'N/A',\r\n      lines: (workspaceRes.lines || []).map(line => ({\r\n        name: line.alertingName || line.description || '',\r\n        number: line.directoryNumber?.directoryNumber || 'NA',\r\n        registered: isRegistered,\r\n      })),\r\n    };\r\n  }\r\n\r\n  private buildUrl(template: string, params: Record<string, string>): string {\r\n    return Object.keys(params).reduce((url, key) => url.replace(`:${key}`, params[key]), template);\r\n  }\r\n\r\n  private buildIssues(typeLabel: string | null | undefined, capacity: number | null | undefined): WorkspaceIssue[] {\r\n    const timestamp = this.formatTimestamp(new Date());\r\n\r\n    return [\r\n      !typeLabel || typeLabel === 'No type' || typeLabel.toLowerCase() === 'notset' ? {\r\n        id: 'type',\r\n        message: 'Workspace type not set',\r\n        timestamp,\r\n        actionLabel: 'Assign type',\r\n        description: 'Adding a type specifies what the workspace is used for.',\r\n        suggestedAction: 'Set a type for this workspace.',\r\n      } : null,\r\n      capacity == null ? {\r\n        id: 'capacity',\r\n        message: 'Workspace capacity not set',\r\n        timestamp,\r\n        actionLabel: 'Set capacity',\r\n        description: 'Adding a capacity specifies how many people can use this workspace.',\r\n        suggestedAction: 'Set a capacity for this workspace.',\r\n      } : null,\r\n    ].filter((issue): issue is NonNullable<typeof issue> => issue !== null);\r\n  }\r\n\r\n  private formatTimestamp(date: Date): string {\r\n    return date.toLocaleString('en-US', {\r\n      year: '2-digit',\r\n      month: 'numeric',\r\n      day: 'numeric',\r\n      hour: 'numeric',\r\n      minute: '2-digit',\r\n      hour12: true,\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/workspaces/src/services/workspaces-migration.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { API } from '../app.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "./api-webex.service";
+export class WorkspacesMigrationService {
+    constructor(apiWebexService) {
+        this.apiWebexService = apiWebexService;
+    }
+    moveToMT(customerId, device) {
+        return this.apiWebexService.post(API.MIGRATION.MOVE, this.getMoveBody(customerId, device));
+    }
+    getMigrationFormStatus(customerId, formId) {
+        const url = API.MIGRATION.MIGRATION_FORM
+            .replace(':customerId', String(customerId))
+            .replace(':formId', String(formId));
+        return this.apiWebexService.fetch(url);
+    }
+    getMigratedMigrationFormEntities(customerId, webexUUID, feature = 'ORPHANED_DEVICE') {
+        const url = API.MIGRATION.MIGRATION_FORM_ENTITIES_MIGRATED.replace(':customerId', String(customerId));
+        return this.apiWebexService.fetch(url, { webexUUID, feature });
+    }
+    triggerFirmwareUpgrade(customerId, migrationFormId, deviceMap) {
+        const url = API.MIGRATION.TRIGGER_FIRMWARE_MIGRATION
+            .replace(':migrationType', 'WEBEX')
+            .replace(':customerId', String(customerId))
+            .replace(':migrationFormId', String(migrationFormId));
+        return this.apiWebexService.post(url, deviceMap);
+    }
+    removeUcmLicense(customerId, migrationFormId, controlHubType = 'WEBEX') {
+        const url = API.MIGRATION.REMOVE_UCM_LICENSE
+            .replace(':controlHubType', controlHubType)
+            .replace(':customerId', String(customerId))
+            .replace(':migrationFormId', String(migrationFormId));
+        return this.apiWebexService.post(url, {});
+    }
+    revertMigration(customerId, personId) {
+        const url = API.MIGRATION.WEBEX_REVERT
+            .replace(':customerId', String(customerId))
+            .replace(':personId', personId);
+        return this.apiWebexService.post(url, {});
+    }
+    getMoveBody(customerId, device) {
+        return {
+            customerId,
+            entities: {
+                ORPHANED_DEVICE: [{ cucmId: device.cucmId, entityId: device.name }],
+            },
+        };
+    }
+}
+WorkspacesMigrationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesMigrationService, deps: [{ token: i1.ApiWebexService }], target: i0.ɵɵFactoryTarget.Injectable });
+WorkspacesMigrationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesMigrationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesMigrationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApiWebexService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/workspaces/src/services/workspaces.service.mjs

@@ -0,0 +1,152 @@
+import { Injectable } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { API } from '../app.constants';
+import { withoutSep } from '../utils/workspace-name';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+function parseResponse(response) {
+    return typeof response === 'string' ? JSON.parse(response) : response;
+}
+function toStatus(provisioningStatus) {
+    if (!provisioningStatus) {
+        return 'unavailable';
+    }
+    return provisioningStatus.toLowerCase() === 'active' ? 'active' : 'inactive';
+}
+function toWorkspaceDevices(item, index) {
+    if (item.workspaceDevices?.length) {
+        return item.workspaceDevices.map(workspaceDevice => ({
+            id: workspaceDevice.deviceId,
+            kind: 'device',
+            label: workspaceDevice.model || workspaceDevice.mac,
+            model: workspaceDevice.model,
+            mac: workspaceDevice.mac,
+        }));
+    }
+    const device = item.device;
+    if (!device) {
+        return [];
+    }
+    const model = device.deviceType || device.userDeviceType || undefined;
+    return [{
+            id: device.pkid || device.webexUUID || device.name || `device-${index}`,
+            kind: 'device',
+            label: model || device.name || 'Unnamed device',
+            model,
+            mac: /^SEP/i.test(device.name || '') ? device.name.slice(3) : undefined,
+        }];
+}
+function toWorkspace(item, index, isCucm) {
+    const device = item.device;
+    const firstDirectoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';
+    return {
+        id: device.pkid || item.workspaceDevices?.[0]?.deviceId || device.name || `workspace-${index}`,
+        displayName: device.newName || device.name || 'Unnamed device',
+        typeLabel: device.userDeviceType || 'No type',
+        capacity: null,
+        location: item.site?.name || device.siteName || device.location || '',
+        siteId: item.site?.id ?? null,
+        devices: toWorkspaceDevices(item, index),
+        scheduling: 'Not set',
+        callingLicense: firstDirectoryNumber,
+        provisioningType: 'On-premises',
+        status: toStatus(device.provisioningStatus),
+        statusLabel: device.provisioningStatus || 'Status unavailable',
+        device,
+        isHybrid: false,
+        cucmDeviceName: isCucm ? (device.name || null) : null,
+    };
+}
+function mergeDevices(a, b) {
+    return {
+        ...a,
+        ...b,
+        cucmId: b.cucmId ?? a.cucmId,
+        webexUUID: b.webexUUID ?? a.webexUUID,
+    };
+}
+function toMacKey(value) {
+    return value ? withoutSep(value).replace(/[^0-9A-F]/g, '') : '';
+}
+function mergeCucmAndWebexWorkspaces(cucmWorkspaces, webexItems, webexWorkspaces) {
+    const result = [...cucmWorkspaces];
+    const cucmIndexByMac = new Map();
+    cucmWorkspaces.forEach((workspace, index) => {
+        const key = toMacKey(workspace.device.name);
+        if (key && !cucmIndexByMac.has(key)) {
+            cucmIndexByMac.set(key, index);
+        }
+    });
+    webexWorkspaces.forEach((webexWorkspace, webexIndex) => {
+        const matchedMac = (webexItems[webexIndex].workspaceDevices || [])
+            .map(workspaceDevice => toMacKey(workspaceDevice.mac))
+            .find(key => key && cucmIndexByMac.has(key));
+        if (!matchedMac) {
+            result.push(webexWorkspace);
+            return;
+        }
+        const cucmIndex = cucmIndexByMac.get(matchedMac);
+        cucmIndexByMac.delete(matchedMac);
+        const cucmWorkspace = result[cucmIndex];
+        result[cucmIndex] = {
+            ...cucmWorkspace,
+            ...webexWorkspace,
+            displayName: cucmWorkspace.displayName,
+            location: webexWorkspace.location || cucmWorkspace.location,
+            siteId: webexWorkspace.siteId ?? cucmWorkspace.siteId,
+            device: {
+                ...mergeDevices(cucmWorkspace.device, webexWorkspace.device),
+                name: cucmWorkspace.device.name,
+                newName: cucmWorkspace.device.newName,
+            },
+            isHybrid: true,
+            cucmDeviceName: cucmWorkspace.cucmDeviceName,
+        };
+    });
+    return result;
+}
+const FETCH_ALL_SIZE = 9999;
+export class WorkspacesService {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    fetchWorkspaces(customerId) {
+        const baseParams = {
+            type: 'ORPHAN_DEVICE',
+            customerid: customerId.toString(),
+            size: FETCH_ALL_SIZE.toString(),
+            page: '0',
+        };
+        const cucm$ = this.apiService.fetch(API.WORKSPACES.GET_ALL, {
+            ...baseParams,
+            'device-name': 'SEP',
+            provisionType: 'CUCM',
+        });
+        const webex$ = this.apiService.fetch(API.WORKSPACES.GET_ALL, {
+            ...baseParams,
+            provisionType: 'WEBEX',
+        });
+        return forkJoin([cucm$, webex$]).pipe(map(([cucmResponse, webexResponse]) => {
+            const cucmParsed = parseResponse(cucmResponse);
+            const webexParsed = parseResponse(webexResponse);
+            const webexItems = webexParsed?.pageData || [];
+            const cucmWorkspaces = (cucmParsed?.pageData || []).map((item, index) => toWorkspace(item, index, true));
+            const webexWorkspaces = webexItems.map((item, index) => toWorkspace(item, index, false));
+            const workspaces = mergeCucmAndWebexWorkspaces(cucmWorkspaces, webexItems, webexWorkspaces);
+            return {
+                workspaces,
+                total: workspaces.length,
+            };
+        }));
+    }
+}
+WorkspacesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesService, deps: [{ token: i1.APIService }], target: i0.ɵɵFactoryTarget.Injectable });
+WorkspacesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.APIService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspaces.service.js","sourceRoot":"","sources":["../../../../../../../projects/tuki/widgets/workspaces/src/services/workspaces.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { forkJoin, Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { API } from '../app.constants';\r\nimport { APIService } from './api.service';\r\nimport { Workspace, WorkspaceDevice, WorkspaceListItem, WorkspacesPage, WorkspacesResponse, WorkspaceStatus } from '../types/workspace';\r\nimport { withoutSep } from '../utils/workspace-name';\r\n\r\nfunction parseResponse(response: any): any {\r\n  return typeof response === 'string' ? JSON.parse(response) : response;\r\n}\r\n\r\nfunction toStatus(provisioningStatus: string | null): WorkspaceStatus {\r\n  if (!provisioningStatus) {\r\n    return 'unavailable';\r\n  }\r\n  return provisioningStatus.toLowerCase() === 'active' ? 'active' : 'inactive';\r\n}\r\n\r\nfunction toWorkspaceDevices(item: WorkspaceListItem, index: number): WorkspaceDevice[] {\r\n  if (item.workspaceDevices?.length) {\r\n    return item.workspaceDevices.map(workspaceDevice => ({\r\n      id: workspaceDevice.deviceId,\r\n      kind: 'device' as const,\r\n      label: workspaceDevice.model || workspaceDevice.mac,\r\n      model: workspaceDevice.model,\r\n      mac: workspaceDevice.mac,\r\n    }));\r\n  }\r\n\r\n  const device = item.device;\r\n  if (!device) {\r\n    return [];\r\n  }\r\n\r\n  const model = device.deviceType || device.userDeviceType || undefined;\r\n  return [{\r\n    id: device.pkid || device.webexUUID || device.name || `device-${index}`,\r\n    kind: 'device' as const,\r\n    label: model || device.name || 'Unnamed device',\r\n    model,\r\n    mac: /^SEP/i.test(device.name || '') ? device.name.slice(3) : undefined,\r\n  }];\r\n}\r\n\r\nfunction toWorkspace(item: WorkspaceListItem, index: number, isCucm: boolean): Workspace {\r\n  const device = item.device;\r\n  const firstDirectoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';\r\n\r\n  return {\r\n    id: device.pkid || item.workspaceDevices?.[0]?.deviceId || device.name || `workspace-${index}`,\r\n    displayName: device.newName || device.name || 'Unnamed device',\r\n    typeLabel: device.userDeviceType || 'No type',\r\n    capacity: null,\r\n    location: item.site?.name || device.siteName || device.location || '',\r\n    siteId: item.site?.id ?? null,\r\n    devices: toWorkspaceDevices(item, index),\r\n    scheduling: 'Not set',\r\n    callingLicense: firstDirectoryNumber,\r\n    provisioningType: 'On-premises',\r\n    status: toStatus(device.provisioningStatus),\r\n    statusLabel: device.provisioningStatus || 'Status unavailable',\r\n    device,\r\n    isHybrid: false,\r\n    cucmDeviceName: isCucm ? (device.name || null) : null,\r\n  };\r\n}\r\n\r\nfunction mergeDevices(a: Workspace['device'], b: Workspace['device']): Workspace['device'] {\r\n  return {\r\n    ...a,\r\n    ...b,\r\n    cucmId: b.cucmId ?? a.cucmId,\r\n    webexUUID: b.webexUUID ?? a.webexUUID,\r\n  };\r\n}\r\n\r\n\r\nfunction toMacKey(value: string | null | undefined): string {\r\n  return value ? withoutSep(value).replace(/[^0-9A-F]/g, '') : '';\r\n}\r\n\r\nfunction mergeCucmAndWebexWorkspaces(cucmWorkspaces: Workspace[], webexItems: WorkspaceListItem[], webexWorkspaces: Workspace[]): Workspace[] {\r\n  const result = [...cucmWorkspaces];\r\n  const cucmIndexByMac = new Map<string, number>();\r\n  cucmWorkspaces.forEach((workspace, index) => {\r\n    const key = toMacKey(workspace.device.name);\r\n    if (key && !cucmIndexByMac.has(key)) {\r\n      cucmIndexByMac.set(key, index);\r\n    }\r\n  });\r\n\r\n  webexWorkspaces.forEach((webexWorkspace, webexIndex) => {\r\n    const matchedMac = (webexItems[webexIndex].workspaceDevices || [])\r\n      .map(workspaceDevice => toMacKey(workspaceDevice.mac))\r\n      .find(key => key && cucmIndexByMac.has(key));\r\n\r\n    if (!matchedMac) {\r\n      result.push(webexWorkspace);\r\n      return;\r\n    }\r\n\r\n    const cucmIndex = cucmIndexByMac.get(matchedMac)!;\r\n    cucmIndexByMac.delete(matchedMac);\r\n    const cucmWorkspace = result[cucmIndex];\r\n    result[cucmIndex] = {\r\n      ...cucmWorkspace,\r\n      ...webexWorkspace,\r\n      displayName: cucmWorkspace.displayName,\r\n      location: webexWorkspace.location || cucmWorkspace.location,\r\n      siteId: webexWorkspace.siteId ?? cucmWorkspace.siteId,\r\n      device: {\r\n        ...mergeDevices(cucmWorkspace.device, webexWorkspace.device),\r\n        name: cucmWorkspace.device.name,\r\n        newName: cucmWorkspace.device.newName,\r\n      },\r\n      isHybrid: true,\r\n      cucmDeviceName: cucmWorkspace.cucmDeviceName,\r\n    };\r\n  });\r\n\r\n  return result;\r\n}\r\n\r\nconst FETCH_ALL_SIZE = 9999;\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WorkspacesService {\r\n  constructor(private apiService: APIService) { }\r\n\r\n  fetchWorkspaces(customerId: string | number): Observable<WorkspacesPage> {\r\n    const baseParams: Record<string, string> = {\r\n      type: 'ORPHAN_DEVICE',\r\n      customerid: customerId.toString(),\r\n      size: FETCH_ALL_SIZE.toString(),\r\n      page: '0',\r\n    };\r\n\r\n    const cucm$ = this.apiService.fetch(API.WORKSPACES.GET_ALL, {\r\n      ...baseParams,\r\n      'device-name': 'SEP',\r\n      provisionType: 'CUCM',\r\n    });\r\n\r\n    const webex$ = this.apiService.fetch(API.WORKSPACES.GET_ALL, {\r\n      ...baseParams,\r\n      provisionType: 'WEBEX',\r\n    });\r\n\r\n    return forkJoin([cucm$, webex$]).pipe(\r\n      map(([cucmResponse, webexResponse]) => {\r\n        const cucmParsed = parseResponse(cucmResponse) as WorkspacesResponse;\r\n        const webexParsed = parseResponse(webexResponse) as WorkspacesResponse;\r\n        const webexItems = webexParsed?.pageData || [];\r\n        const cucmWorkspaces = (cucmParsed?.pageData || []).map((item, index) => toWorkspace(item, index, true));\r\n        const webexWorkspaces = webexItems.map((item, index) => toWorkspace(item, index, false));\r\n        const workspaces = mergeCucmAndWebexWorkspaces(cucmWorkspaces, webexItems, webexWorkspaces);\r\n\r\n        return {\r\n          workspaces,\r\n          total: workspaces.length,\r\n        };\r\n      }),\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2020/workspaces/src/types/workspace.mjs

@@ -0,0 +1,4 @@
+// Raw shapes returned by /api/search/quicknonuserdevices (a paginated CUCM
+// non-user/shared device search, reused here as the "Workspaces" list).
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../../../../../../projects/tuki/widgets/workspaces/src/types/workspace.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,wEAAwE","sourcesContent":["// Raw shapes returned by /api/search/quicknonuserdevices (a paginated CUCM\r\n// non-user/shared device search, reused here as the \"Workspaces\" list).\r\n\r\nexport interface WorkspaceAssociatedDirectoryNumber {\r\n  directoryNumber: string;\r\n  routePartitionName: string;\r\n  pkid: string | null;\r\n  dnType: string | null;\r\n  subType: string | null;\r\n}\r\n\r\nexport interface WorkspaceLineAssociation {\r\n  linePkid: string | null;\r\n  index: number | null;\r\n  position: number | null;\r\n}\r\n\r\nexport interface WorkspaceSite {\r\n  id: number;\r\n  name: string;\r\n}\r\n\r\nexport interface WorkspaceDeviceAssociation {\r\n  deviceId: string;\r\n  mac: string;\r\n  model: string;\r\n}\r\n\r\nexport interface WorkspaceDeviceRecord {\r\n  name: string;\r\n  newName: string;\r\n  pkid: string | null;\r\n  entityChangeType: string | null;\r\n  deviceType: string | null;\r\n  activeLoadId: string | null;\r\n  associatedDNs: WorkspaceAssociatedDirectoryNumber[];\r\n  authenticationMode: string | null;\r\n  authenticationString: string | null;\r\n  builtInBridge: string | null;\r\n  busyLampFields: unknown[];\r\n  buttonTemplate: string | null;\r\n  callingSearchSpaceName: string | null;\r\n  certificateOperation: string | null;\r\n  certificateStatus: string | null;\r\n  changedLineAppEntity: string | null;\r\n  changedMeetMeEntity: string | null;\r\n  commonPhoneConfigName: string | null;\r\n  ctiRemoteDevice: boolean;\r\n  cucmId: string | null;\r\n  customerId: number;\r\n  description: string | null;\r\n  devicePoolName: string | null;\r\n  deviceRegStatus: string | null;\r\n  deviceSecurityMode: string | null;\r\n  enabledExtensionMobility: boolean;\r\n  excludeDeviceExtraOptions: boolean;\r\n  extraOptions: unknown | null;\r\n  firmwareVersion: string | null;\r\n  firstExpansionModule: string | null;\r\n  intercomLineAssociations: unknown[];\r\n  ipAddress: string | null;\r\n  lastRegTime: string | null;\r\n  lineAssociations: WorkspaceLineAssociation[];\r\n  lines: unknown[];\r\n  location: string | null;\r\n  meetMeEnabled: boolean;\r\n  networkLocale: string | null;\r\n  operationCompletesBy: string | null;\r\n  ownerUserId: string | null;\r\n  plarDevice: boolean;\r\n  protocol: string | null;\r\n  provisioningStatus: string | null;\r\n  reroutingCss: string | null;\r\n  rsaKeySize: string | null;\r\n  secondExpansionModule: string | null;\r\n  securityProfile: string | null;\r\n  securityProfileUuid: string | null;\r\n  selectedDevicesAarSettings: unknown[];\r\n  selectedDevicesAdditionalInfos: unknown[];\r\n  selectedDevicesDndSettings: unknown[];\r\n  selectedDevicesExternalDataLocations: unknown[];\r\n  selectedDevicesGeneralInfos: unknown[];\r\n  selectedDevicesMediaSettings: unknown[];\r\n  selectedDevicesMlppInfos: unknown[];\r\n  selectedDevicesNumberPresentations: unknown[];\r\n  selectedDevicesPhoneSpecifics: unknown[];\r\n  selectedDevicesProtocolSpecifics: unknown[];\r\n  selectedIndex: number;\r\n  services: string[];\r\n  sharedUsers: string[];\r\n  sipProfile: string | null;\r\n  siteId: number;\r\n  siteName: string | null;\r\n  softkeyTemplate: string | null;\r\n  speedDials: unknown[];\r\n  subscribeCallingSearchSpaceName: string | null;\r\n  thirdExpansionModule: string | null;\r\n  unSupportedForSD: unknown | null;\r\n  userDeviceType: string | null;\r\n  userLocale: string | null;\r\n  voicemailEnabled: boolean;\r\n  webexUUID: string | null;\r\n  withUdp: boolean;\r\n}\r\n\r\nexport interface WorkspaceListItem {\r\n  device: WorkspaceDeviceRecord;\r\n  lines: unknown[];\r\n  site: WorkspaceSite | null;\r\n  workspaceDevices: WorkspaceDeviceAssociation[];\r\n}\r\n\r\nexport interface WorkspacesResponse {\r\n  total: number;\r\n  pageData: WorkspaceListItem[];\r\n}\r\n\r\n// Display-friendly shape consumed by the filters/table components.\r\n\r\nexport type WorkspaceStatus = 'active' | 'inactive' | 'unavailable';\r\n\r\nexport interface WorkspaceDevice {\r\n  id: string;\r\n  kind: 'device' | 'person';\r\n  label: string;\r\n  initials?: string;\r\n  color?: string;\r\n  model?: string;\r\n  mac?: string;\r\n}\r\n\r\nexport interface WorkspacesPage {\r\n  workspaces: Workspace[];\r\n  total: number;\r\n}\r\n\r\nexport interface Workspace {\r\n  id: string;\r\n  displayName: string;\r\n  typeLabel: string;\r\n  capacity: number | null;\r\n  location: string;\r\n  siteId: number | null;\r\n  devices: WorkspaceDevice[];\r\n  scheduling: string;\r\n  callingLicense: string;\r\n  provisioningType: string;\r\n  status: WorkspaceStatus;\r\n  statusLabel: string;\r\n  device: WorkspaceDeviceRecord;\r\n  isHybrid: boolean;\r\n  // The CUCM device's own name (e.g. \"SEP...\") as it was before merging with\r\n  // its Webex counterpart, which can otherwise overwrite device.name. Used to\r\n  // address the CUCM detail endpoint for a hybrid workspace.\r\n  cucmDeviceName: string | null;\r\n}\r\n\r\n// Which identity a workspace should be opened/addressed by: the plain Webex\r\n// Calling connection (keyed by device.webexUUID) or the Webex Calling DI /\r\n// on-prem connection (keyed by device.name). A hybrid workspace has both and\r\n// the caller picks which one they clicked; a non-hybrid workspace only ever\r\n// has one of the two set.\r\nexport type WorkspaceConnectionType = 'webex' | 'di';\r\n\r\nexport interface WorkspaceOpenEvent {\r\n  id: string;\r\n  connectionType: WorkspaceConnectionType;\r\n}\r\n\r\n// Mock data shown on the workspace detail (Overview / Calling) view, until a\r\n// dedicated detail API is available.\r\n\r\nexport interface WorkspaceIssue {\r\n  id: string;\r\n  message: string;\r\n  timestamp: string;\r\n  actionLabel: string;\r\n  description: string;\r\n  suggestedAction: string;\r\n}\r\n\r\nexport interface WorkspaceLocationDetails {\r\n  country: string;\r\n  address: string;\r\n}\r\n\r\nexport interface WorkspaceCallingDetails {\r\n  license: string;\r\n  sipAddress: string;\r\n  directoryNumber: string;\r\n  extension?: string;\r\n  routePartition: string;\r\n  callingSearchSpace: string;\r\n  securityProfile: string;\r\n  externalCallerIdName?: string;\r\n  externalCallerIdNumber?: string;\r\n}\r\n\r\nexport interface WorkspaceDeviceLine {\r\n  name: string;\r\n  number: string;\r\n  registered: boolean;\r\n}\r\n\r\nexport interface WorkspaceDeviceDetails {\r\n  model: string;\r\n  registrationStatus: string;\r\n  mac: string;\r\n  lineCount: number | null;\r\n  hostIpAddress: string;\r\n  remoteIpAddress: string;\r\n  managedBy: string;\r\n  softwareChannel: string;\r\n  softwareVersion: string;\r\n  lines: WorkspaceDeviceLine[];\r\n}\r\n\r\nexport interface WorkspaceDetails {\r\n  issues: WorkspaceIssue[];\r\n  location: WorkspaceLocationDetails;\r\n  calling: WorkspaceCallingDetails;\r\n  schedulingConfigured: boolean;\r\n  plannedMaintenanceEnabled: boolean;\r\n  notes: string | null;\r\n  capacity?: number | null;\r\n  device?: WorkspaceDeviceDetails;\r\n}\r\n\r\n// Raw shapes returned by the Webex Calling workspace-detail endpoints\r\n// (API.DETAILS.WEBEX.WORKSPACE / NUMBERS / CALLERID).\r\n\r\nexport interface WebexWorkspaceDeviceSummary {\r\n  deviceId: string;\r\n  mac: string;\r\n  model: string;\r\n  registered: string | null;\r\n}\r\n\r\nexport interface WebexWorkspaceDetailsResponse {\r\n  customerId: number;\r\n  capacity: number | null;\r\n  devices: WebexWorkspaceDeviceSummary[];\r\n  extensions: string[];\r\n  licenseName: string;\r\n  locationId: string;\r\n  locationName: string;\r\n  sipAddress: string;\r\n  type: string;\r\n  workspaceId: string;\r\n  workspaceName: string;\r\n}\r\n\r\nexport interface WebexNumberLocation {\r\n  id: string;\r\n  name: string;\r\n  orgId: string;\r\n  address: string | null;\r\n  announcementLanguage: string | null;\r\n  city: string | null;\r\n  country: string | null;\r\n  emailLanguage: string | null;\r\n  postalCode: string | null;\r\n  preferredLanguage: string | null;\r\n  state: string | null;\r\n  timeZone: string | null;\r\n}\r\n\r\nexport interface WebexNumberOrganization {\r\n  id: string;\r\n  name: string;\r\n}\r\n\r\nexport interface WebexPhoneNumber {\r\n  esn: string | null;\r\n  extension: string | null;\r\n  external: string | null;\r\n  primary: boolean;\r\n  workspace?: { id: string };\r\n}\r\n\r\nexport interface WebexNumbersResponse {\r\n  phoneNumbers: WebexPhoneNumber[];\r\n  location: WebexNumberLocation;\r\n  organization: WebexNumberOrganization;\r\n}\r\n\r\nexport interface WebexCallerIdResponse {\r\n  types: string[];\r\n  selected: string;\r\n  blockInForwardCallsEnabled: boolean;\r\n  customExternalCallerIdName: string | null;\r\n  customNumber: string | null;\r\n  customerNumber: string | null;\r\n  directNumber: string | null;\r\n  displayDetail: string | null;\r\n  displayName: string | null;\r\n  externalCallerIdNamePolicy: string | null;\r\n  locationExternalCallerIdName: string | null;\r\n  locationNumber: string | null;\r\n  tollFreeLocationNumber: boolean;\r\n}\r\n\r\n// Raw shapes returned by the CUCM workspace-detail endpoints\r\n// (API.DETAILS.CUCM.WORKSPACE / SITE).\r\n\r\nexport interface CucmCallInfoDisplay {\r\n  callerName: string;\r\n  callerNumber: string;\r\n  redirectedNumber: string;\r\n  dialedNumber: string;\r\n}\r\n\r\nexport interface CucmLineAssociation {\r\n  linePkid: string | null;\r\n  index: number | null;\r\n  position: number | null;\r\n  directoryNumber: WorkspaceAssociatedDirectoryNumber;\r\n  e164Mask: string | null;\r\n  textLabel: string | null;\r\n  displayLabel: string | null;\r\n  displayLabelAscii: string | null;\r\n  maxNumberOfCalls: number | null;\r\n  busyTrigger: number | null;\r\n  recordingOption: string | null;\r\n  recordingProfile: string | null;\r\n  recordingMediaSource: string | null;\r\n  visualMWI: string | null;\r\n  audibleMWI: string | null;\r\n  ringSetting_idle: string | null;\r\n  ringSetting_active: string | null;\r\n  pickupAAS_idle: string | null;\r\n  pickupAAS_active: string | null;\r\n  monitorCSS: string | null;\r\n  logMissedCall: string | null;\r\n  callInfoDisplay: CucmCallInfoDisplay;\r\n  lineLocalId: string | null;\r\n  didPattern: unknown | null;\r\n  sharedDevices: unknown[];\r\n  sharedUsers: unknown[];\r\n  ownerUserId: unknown[];\r\n  associated: unknown | null;\r\n  patternUsage: unknown | null;\r\n  alertingName: string | null;\r\n  populateWithDid: boolean;\r\n}\r\n\r\nexport interface CucmService {\r\n  name: string;\r\n  telecasterServiceName: string;\r\n}\r\n\r\nexport interface CucmDeviceDetails extends Omit<WorkspaceDeviceRecord, 'lineAssociations' | 'services'> {\r\n  lineAssociations: CucmLineAssociation[];\r\n  services: CucmService[];\r\n}\r\n\r\nexport interface CucmCallForwardSetting {\r\n  forwardToVoiceMail: boolean | null;\r\n  destination: string | null;\r\n  callingSearchSpace: string | null;\r\n  duration: number | null;\r\n}\r\n\r\nexport interface CucmAarSettings {\r\n  aarDestinationMask: string | null;\r\n  aarGroup: string | null;\r\n  aarVoiceMailEnabled: boolean;\r\n  aarKeepCallHistory: boolean;\r\n}\r\n\r\nexport interface CucmParkMonitoring {\r\n  destination: string | null;\r\n  callingSearchSpace: string | null;\r\n  voiceMail: boolean;\r\n}\r\n\r\nexport interface CucmDidPattern {\r\n  pkid: string | null;\r\n  pattern: string | null;\r\n  newPattern: string | null;\r\n  calledPartyTransformationMask: string | null;\r\n  description: string | null;\r\n  useOriginatorCss: unknown | null;\r\n  callingSearchSpaceName: string | null;\r\n  routePartitionName: string | null;\r\n  newRoutePartitionName: string | null;\r\n  urgentPriority: boolean;\r\n  outgoingCalls: unknown | null;\r\n}\r\n\r\nexport interface CucmLineDetails {\r\n  directoryNumber: WorkspaceAssociatedDirectoryNumber;\r\n  pkid: string | null;\r\n  description: string | null;\r\n  entityChangeType: string | null;\r\n  alertingName: string | null;\r\n  asciiAlertingName: string | null;\r\n  callingSearchSpace: string | null;\r\n  callForwardAll: CucmCallForwardSetting;\r\n  callForwardAllSecondaryCSS: CucmCallForwardSetting;\r\n  callForwardBusyInternal: CucmCallForwardSetting;\r\n  callForwardBusyExternal: CucmCallForwardSetting;\r\n  callForwardNoAnswerInternal: CucmCallForwardSetting;\r\n  callForwardNoAnswerExternal: CucmCallForwardSetting;\r\n  callForwardNoCoverageInternal: CucmCallForwardSetting;\r\n  callForwardNoCoverageExternal: CucmCallForwardSetting;\r\n  callForwardOnCTIFailure: CucmCallForwardSetting;\r\n  callForwardUnregisteredInternal: CucmCallForwardSetting;\r\n  callForwardUnregisteredExternal: CucmCallForwardSetting;\r\n  callForwardAlternateParty: CucmCallForwardSetting;\r\n  voiceMailProfile: string | null;\r\n  noAnswerRingDuration: number | null;\r\n  autoAnswer: string | null;\r\n  callPickupGroup: string | null;\r\n  aarSettings: CucmAarSettings;\r\n  parkMonitoringInternal: CucmParkMonitoring;\r\n  parkMonitoringExternal: CucmParkMonitoring;\r\n  urgentPriority: boolean;\r\n  blfPresenceGroup: string | null;\r\n  userHoldMOHAudioSourceId: string | null;\r\n  userHoldMOHAudioSourceName: string | null;\r\n  networkMOHAudioSourceId: string | null;\r\n  networkMOHAudioSourceName: string | null;\r\n  rejectAnonymousCall: boolean;\r\n  enterpriseAltNum: unknown | null;\r\n  e164AltNum: unknown | null;\r\n  directoryUris: unknown[];\r\n  mlppNoAnswerRingDuration: number | null;\r\n  confidentialAccessMode: unknown | null;\r\n  confidentialAccessLevel: unknown | null;\r\n  confidentialAccessLevelName: unknown | null;\r\n  callControlAgentProfile: unknown | null;\r\n  holdReversionRingDuration: number | null;\r\n  holdReversionNotificationInterval: number | null;\r\n  partyEntranceTone: string | null;\r\n  pstnFailover: string | null;\r\n  localId: string | null;\r\n  customerId: number;\r\n  cucmId: number;\r\n  siteId: number;\r\n  siteName: string | null;\r\n  location: string | null;\r\n  locationNames: string[];\r\n  selectedIndex: number;\r\n  didPatterns: CucmDidPattern[];\r\n  mappedDids: string[];\r\n  selectedLinesGeneralSettings: unknown[];\r\n  selectedLinesAssociatedSettings: unknown[];\r\n  selectedLinesMultipleCalls: unknown[];\r\n  selectedLinesCallRecordings: unknown[];\r\n  selectedLinesAdditionalSettings: unknown[];\r\n  selectedLinesForwardCalls: unknown[];\r\n  newToUser: boolean;\r\n  plarDestinationNumber: string | null;\r\n  prefixDigits: string | null;\r\n  plarDescription: string | null;\r\n  plarCss: string | null;\r\n  plarRoutePartition: string | null;\r\n  plarEnabled: boolean;\r\n}\r\n\r\nexport interface CucmWorkspaceDetailsResponse {\r\n  device: CucmDeviceDetails;\r\n  lines: CucmLineDetails[];\r\n  site: WorkspaceSite | null;\r\n  workspaceDevices: WorkspaceDeviceAssociation[];\r\n}\r\n\r\nexport interface CucmSiteCucInfo {\r\n  id: number;\r\n  name: string;\r\n}\r\n\r\nexport interface CucmSiteCucmInfo {\r\n  platformType: string;\r\n  id: number;\r\n  name: string;\r\n}\r\n\r\nexport interface CucmSiteResponse {\r\n  id: number;\r\n  name: string;\r\n  shortName: string;\r\n  address2: string | null;\r\n  address3: string | null;\r\n  country: string | null;\r\n  cuc: CucmSiteCucInfo | null;\r\n  cucm: CucmSiteCucmInfo | null;\r\n  hasActivated: boolean;\r\n  hqStatus: boolean;\r\n  isAfterTtu: boolean;\r\n  locationName: string;\r\n  prefetchDn: boolean;\r\n  settings: unknown[];\r\n  state: string | null;\r\n  timezone: string | null;\r\n}\r\n"]}

package/esm2020/workspaces/src/utils/app-loader/app-loader.mjs

@@ -0,0 +1,14 @@
+import { Component, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/progress-spinner";
+export class AppLoaderComponent {
+    constructor() {
+    }
+}
+AppLoaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppLoaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AppLoaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: AppLoaderComponent, selector: "app-loader", ngImport: i0, template: "<div class=\"overlay\">\r\n  <mat-progress-spinner\r\n    class=\"page-spinner\"\r\n    mode=\"indeterminate\"\r\n    [diameter]=\"70\"\r\n    strokeWidth=\"3\"></mat-progress-spinner>\r\n</div>\r\n", styles: [".overlay{position:fixed;width:100%;height:100%;inset:0;background-color:#fff3;z-index:200}.mat-progress-spinner circle,.mat-spinner circle{stroke:#000!important}\n"], dependencies: [{ kind: "component", type: i1.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "diameter", "strokeWidth", "mode", "value"], exportAs: ["matProgressSpinner"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppLoaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-loader', encapsulation: ViewEncapsulation.None, template: "<div class=\"overlay\">\r\n  <mat-progress-spinner\r\n    class=\"page-spinner\"\r\n    mode=\"indeterminate\"\r\n    [diameter]=\"70\"\r\n    strokeWidth=\"3\"></mat-progress-spinner>\r\n</div>\r\n", styles: [".overlay{position:fixed;width:100%;height:100%;inset:0;background-color:#fff3;z-index:200}.mat-progress-spinner circle,.mat-spinner circle{stroke:#000!important}\n"] }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWxvYWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R1a2kvd2lkZ2V0cy93b3Jrc3BhY2VzL3NyYy91dGlscy9hcHAtbG9hZGVyL2FwcC1sb2FkZXIudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dWtpL3dpZGdldHMvd29ya3NwYWNlcy9zcmMvdXRpbHMvYXBwLWxvYWRlci9hcHAtbG9hZGVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQVE3RCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCO0lBQ0EsQ0FBQzs7Z0hBRlUsa0JBQWtCO29HQUFsQixrQkFBa0Isa0RDUi9CLHdNQU9BOzRGRENhLGtCQUFrQjtrQkFOOUIsU0FBUzsrQkFDRSxZQUFZLGlCQUdQLGlCQUFpQixDQUFDLElBQUkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FwcC1sb2FkZXInLFxyXG4gIHRlbXBsYXRlVXJsOiAnLi9hcHAtbG9hZGVyLmNvbXBvbmVudC5odG1sJyxcclxuICBzdHlsZVVybHM6IFsnLi9hcHAtbG9hZGVyLmNvbXBvbmVudC5zY3NzJ10sXHJcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEFwcExvYWRlckNvbXBvbmVudCB7XHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgfVxyXG5cclxufVxyXG4iLCI8ZGl2IGNsYXNzPVwib3ZlcmxheVwiPlxyXG4gIDxtYXQtcHJvZ3Jlc3Mtc3Bpbm5lclxyXG4gICAgY2xhc3M9XCJwYWdlLXNwaW5uZXJcIlxyXG4gICAgbW9kZT1cImluZGV0ZXJtaW5hdGVcIlxyXG4gICAgW2RpYW1ldGVyXT1cIjcwXCJcclxuICAgIHN0cm9rZVdpZHRoPVwiM1wiPjwvbWF0LXByb2dyZXNzLXNwaW5uZXI+XHJcbjwvZGl2PlxyXG4iXX0=

package/esm2020/workspaces/src/utils/device-icon.mjs

@@ -0,0 +1,13 @@
+const DEFAULT_DEVICE_ICON = 'assets/icons/cisco_8851.png';
+const DEVICE_MODEL_ICONS = {
+    'cisco 8851': 'assets/icons/cisco_8851.png',
+    'cisco 8845': 'assets/icons/cisco_8845.png',
+    'cisco 9841': 'assets/icons/cisco_9841.png',
+};
+export function getDeviceIcon(model) {
+    if (!model) {
+        return DEFAULT_DEVICE_ICON;
+    }
+    return DEVICE_MODEL_ICONS[model.trim().toLowerCase()] ?? DEFAULT_DEVICE_ICON;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV2aWNlLWljb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dWtpL3dpZGdldHMvd29ya3NwYWNlcy9zcmMvdXRpbHMvZGV2aWNlLWljb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxtQkFBbUIsR0FBRyw2QkFBNkIsQ0FBQztBQUUxRCxNQUFNLGtCQUFrQixHQUEyQjtJQUNqRCxZQUFZLEVBQUUsNkJBQTZCO0lBQzNDLFlBQVksRUFBRSw2QkFBNkI7SUFDM0MsWUFBWSxFQUFFLDZCQUE2QjtDQUM1QyxDQUFDO0FBRUYsTUFBTSxVQUFVLGFBQWEsQ0FBQyxLQUFjO0lBQzFDLElBQUksQ0FBQyxLQUFLLEVBQUU7UUFDVixPQUFPLG1CQUFtQixDQUFDO0tBQzVCO0lBQ0QsT0FBTyxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUMsSUFBSSxtQkFBbUIsQ0FBQztBQUMvRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgREVGQVVMVF9ERVZJQ0VfSUNPTiA9ICdhc3NldHMvaWNvbnMvY2lzY29fODg1MS5wbmcnO1xyXG5cclxuY29uc3QgREVWSUNFX01PREVMX0lDT05TOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0ge1xyXG4gICdjaXNjbyA4ODUxJzogJ2Fzc2V0cy9pY29ucy9jaXNjb184ODUxLnBuZycsXHJcbiAgJ2Npc2NvIDg4NDUnOiAnYXNzZXRzL2ljb25zL2Npc2NvXzg4NDUucG5nJyxcclxuICAnY2lzY28gOTg0MSc6ICdhc3NldHMvaWNvbnMvY2lzY29fOTg0MS5wbmcnLFxyXG59O1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGdldERldmljZUljb24obW9kZWw/OiBzdHJpbmcpOiBzdHJpbmcge1xyXG4gIGlmICghbW9kZWwpIHtcclxuICAgIHJldHVybiBERUZBVUxUX0RFVklDRV9JQ09OO1xyXG4gIH1cclxuICByZXR1cm4gREVWSUNFX01PREVMX0lDT05TW21vZGVsLnRyaW0oKS50b0xvd2VyQ2FzZSgpXSA/PyBERUZBVUxUX0RFVklDRV9JQ09OO1xyXG59XHJcbiJdfQ==

package/esm2020/workspaces/src/utils/workspace-name.mjs

@@ -0,0 +1,8 @@
+// CUCM and Webex Calling device names for the same physical workspace can differ
+// only by the 'SEP' substring (Cisco's MAC-based device naming for CUCM
+// endpoints). Comparing/rendering with it stripped is how the two get treated
+// as one workspace, without altering the underlying device name data.
+export function withoutSep(name) {
+    return name.toLocaleUpperCase().replace(/SEP/gi, '');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLW5hbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dWtpL3dpZGdldHMvd29ya3NwYWNlcy9zcmMvdXRpbHMvd29ya3NwYWNlLW5hbWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsaUZBQWlGO0FBQ2pGLHdFQUF3RTtBQUN4RSw4RUFBOEU7QUFDOUUsc0VBQXNFO0FBQ3RFLE1BQU0sVUFBVSxVQUFVLENBQUMsSUFBWTtJQUNyQyxPQUFPLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDdkQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENVQ00gYW5kIFdlYmV4IENhbGxpbmcgZGV2aWNlIG5hbWVzIGZvciB0aGUgc2FtZSBwaHlzaWNhbCB3b3Jrc3BhY2UgY2FuIGRpZmZlclxyXG4vLyBvbmx5IGJ5IHRoZSAnU0VQJyBzdWJzdHJpbmcgKENpc2NvJ3MgTUFDLWJhc2VkIGRldmljZSBuYW1pbmcgZm9yIENVQ01cclxuLy8gZW5kcG9pbnRzKS4gQ29tcGFyaW5nL3JlbmRlcmluZyB3aXRoIGl0IHN0cmlwcGVkIGlzIGhvdyB0aGUgdHdvIGdldCB0cmVhdGVkXHJcbi8vIGFzIG9uZSB3b3Jrc3BhY2UsIHdpdGhvdXQgYWx0ZXJpbmcgdGhlIHVuZGVybHlpbmcgZGV2aWNlIG5hbWUgZGF0YS5cclxuZXhwb3J0IGZ1bmN0aW9uIHdpdGhvdXRTZXAobmFtZTogc3RyaW5nKTogc3RyaW5nIHtcclxuICByZXR1cm4gbmFtZS50b0xvY2FsZVVwcGVyQ2FzZSgpLnJlcGxhY2UoL1NFUC9naSwgJycpO1xyXG59XHJcbiJdfQ==