@tuki-io/tuki-widgets 0.0.134 → 0.0.136

package/esm2020/di2mt/widgets/site-upgrade/site-upgrade.module.mjs

@@ -0,0 +1,53 @@
+import { NgModule } from "@angular/core";
+import { SiteUpgradeDataTableComponent } from "./site-upgrade-data-table/site-upgrade-data-table.component";
+import { CommonModule } from "@angular/common";
+import { MatTableModule } from "@angular/material/table";
+import { MatIconModule } from "@angular/material/icon";
+import { MatButtonModule } from "@angular/material/button";
+import { SharedModule } from "../../shared/shared.module";
+import { MatMenuModule } from '@angular/material/menu';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { ProgressBarComponent } from './progress-bar/progress-bar.component';
+import * as i0 from "@angular/core";
+export class SiteUpgradeModule {
+}
+SiteUpgradeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SiteUpgradeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeModule, declarations: [SiteUpgradeDataTableComponent,
+        ProgressBarComponent], imports: [CommonModule,
+        SharedModule,
+        MatTableModule,
+        MatIconModule,
+        MatMenuModule,
+        MatButtonModule,
+        MatProgressSpinnerModule], exports: [SiteUpgradeDataTableComponent,
+        ProgressBarComponent] });
+SiteUpgradeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeModule, imports: [CommonModule,
+        SharedModule,
+        MatTableModule,
+        MatIconModule,
+        MatMenuModule,
+        MatButtonModule,
+        MatProgressSpinnerModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SiteUpgradeDataTableComponent,
+                        ProgressBarComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        SharedModule,
+                        MatTableModule,
+                        MatIconModule,
+                        MatMenuModule,
+                        MatButtonModule,
+                        MatProgressSpinnerModule
+                    ],
+                    exports: [
+                        SiteUpgradeDataTableComponent,
+                        ProgressBarComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/di2mt/widgets/site-upgrade/site-upgrade.service.mjs

@@ -0,0 +1,92 @@
+import { inject, Injectable } from "@angular/core";
+import { map, Subject } from "rxjs";
+import { API } from "../../api/api.endpoints";
+import { APIService } from "../../shared/services/api.service";
+import * as i0 from "@angular/core";
+export class SiteUpgradeService {
+    constructor() {
+        this.siteUpdateStatusEvent = new Subject();
+        this.apiService = inject(APIService);
+    }
+    getSiteUpgradeStatusCounts() {
+        return this.apiService.fetch(API.SITE_UPGRADE.GET_SITES_UPGRADE_STATUS_COUNTS.replace(':customerId', this.customerId));
+    }
+    getSiteUpgradeRecords() {
+        return this.apiService.fetch(API.SITE_UPGRADE.GET_SITES_UPGRADE_DATA.replace(':customerId', this.customerId)).pipe(map((resp) => {
+            return resp.content.map((record) => ({
+                siteId: record.siteId,
+                siteName: record.siteName,
+                totalUsers: record.totalUsers,
+                totalReadyUsers: record.readyUsers,
+                totalNotReadyUsers: record.notReadyUsers,
+                totalUpgradedUsers: record.totalUpgradedUsers,
+                totalFailedUsers: record.totalFailedToUpgradeUsers,
+                locationMapping: record.locationMappingStatus,
+                PSTNTrunk: record.pstnTrunkStatus,
+                upgradeStatus: record.siteUpgradeStatus
+            }));
+        }));
+    }
+    getBatchSites() {
+        return this.apiService.fetch(API.SITE_UPGRADE.GET_BATCH_SITES.replace(':customerId', this.customerId));
+    }
+    collectSiteCache(siteId, migrationType = 'webex') {
+        return this.apiService.post(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION
+            .replace(':siteId', String(siteId))
+            .replace(':migrationType', migrationType), {});
+    }
+    migrateSite(siteId, batchId) {
+        return this.apiService.post(API.SITE_UPGRADE.MIGRATE_SITE.replace(':siteId', String(siteId)), {}, { batchId: batchId || '' });
+    }
+    getBatchesStatuses(batchIds) {
+        return this.apiService.post(API.SITE_UPGRADE.WEBEX_BATCH_STATUS
+            .replace(':customerId', this.customerId), batchIds, false)
+            .pipe(map((result) => {
+            this.siteUpdateStatusEvent.next(result);
+            return result;
+        }));
+    }
+    getSiteListForCollectAndBuildWebexCache() {
+        return this.apiService.fetch(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION_SITE_LIST.replace(':customerId', this.customerId))
+            .pipe(map((siteSet) => this.siteSetForCollectAndBuildWebexCache = siteSet));
+    }
+    getCUCMListCurrentlyInCollectAndBuildWebexCache() {
+        return this.apiService.fetch(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION_CUCM_LIST.replace(':customerId', this.customerId))
+            .pipe(map((cucmSet) => this.cucmSetInCollectAndBuildWebexCache = cucmSet));
+    }
+    getMigrationBatchesStatuses() {
+        return this.apiService.fetch(API.SITE_UPGRADE.BATCH_STATUS.replace(':customerId', this.customerId));
+        /*.pipe(map((result: BatchStatusDTO[]) => {
+          this.siteUpdateStatusEvent.next(result);
+          return result;
+        }))*/
+    }
+    getMigratedSiteStatus(pageSize, page) {
+        return this.apiService.fetchPagination(API.SITE_UPGRADE.MIGRATION_STATUS.replace(':customerId', this.customerId), pageSize, page, {}, false);
+    }
+    // TODO: Impl the site upgrade logic here
+    upgradeSite(site) {
+        const customerId = site.customerId;
+        const siteId = site.siteId;
+    }
+}
+SiteUpgradeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SiteUpgradeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SiteUpgradeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+export const STATUSES = {
+    COMPLETED: 'Completed',
+    NEW: 'New',
+    IN_PROGRESS: 'In Progress',
+    FAILED_IN_ERROR: 'Failed-in error',
+    FAILED: 'Failed',
+    FAILED_WITH_RETRY: 'Failed with Retry',
+    COLLECTING: 'Collecting',
+    FAILED_COLLECTING: 'Failed on collecting',
+    WAITING_FOR_REVIEW: 'Waiting for review'
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"site-upgrade.service.js","sourceRoot":"","sources":["../../../../../../../projects/tuki/widgets/di2mt/widgets/site-upgrade/site-upgrade.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from \"@angular/core\";\r\nimport { map, Observable, Subject } from \"rxjs\";\r\nimport { SiteUpgradeRecord } from \"./types/user-upgrade\";\r\nimport { API } from \"../../api/api.endpoints\";\r\nimport { UserUpgradeRecord } from \"../user-upgrade/types/user-upgrade\";\r\nimport { APIService } from \"../../shared/services/api.service\";\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SiteUpgradeService {\r\n  siteSetForCollectAndBuildWebexCache: number[] | undefined;\r\n  cucmSetInCollectAndBuildWebexCache: number[] | undefined;\r\n  siteUpdateStatusEvent = new Subject<BatchStatusDTO[]>();\r\n  private apiService = inject(APIService);\r\n  customerId!: string;\r\n\r\n  getSiteUpgradeStatusCounts(): Observable<any> {\r\n    return this.apiService.fetch(\r\n      API.SITE_UPGRADE.GET_SITES_UPGRADE_STATUS_COUNTS.replace(':customerId', this.customerId)\r\n    );\r\n  }\r\n\r\n  getSiteUpgradeRecords(): Observable<SiteUpgradeRecord[]> {\r\n    return this.apiService.fetch(\r\n      API.SITE_UPGRADE.GET_SITES_UPGRADE_DATA.replace(':customerId', this.customerId)\r\n    ).pipe(map((resp) => {\r\n      return resp.content.map((record: any) => ({\r\n        siteId: record.siteId,\r\n        siteName: record.siteName,\r\n        totalUsers: record.totalUsers,\r\n        totalReadyUsers: record.readyUsers,\r\n        totalNotReadyUsers: record.notReadyUsers,\r\n        totalUpgradedUsers: record.totalUpgradedUsers,\r\n        totalFailedUsers: record.totalFailedToUpgradeUsers,\r\n        locationMapping: record.locationMappingStatus,\r\n        PSTNTrunk: record.pstnTrunkStatus,\r\n        upgradeStatus: record.siteUpgradeStatus\r\n      } as SiteUpgradeRecord));\r\n    }));\r\n  }\r\n\r\n  getBatchSites(): Observable<MigrationBatch[]> {\r\n    return this.apiService.fetch(\r\n      API.SITE_UPGRADE.GET_BATCH_SITES.replace(':customerId', this.customerId)\r\n    );\r\n  }\r\n\r\n  collectSiteCache(siteId: number, migrationType: string = 'webex') {\r\n    return this.apiService.post(\r\n      API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION\r\n        .replace(':siteId', String(siteId))\r\n        .replace(':migrationType', migrationType),\r\n      {}\r\n    )\r\n  }\r\n\r\n  migrateSite(siteId: string, batchId: string): Observable<any> {\r\n    return this.apiService.post(\r\n      API.SITE_UPGRADE.MIGRATE_SITE.replace(':siteId', String(siteId)),\r\n      {},\r\n      {batchId: batchId || ''}\r\n    )\r\n  }\r\n\r\n  getBatchesStatuses(batchIds: string[]): Observable<BatchStatusDTO[]> {\r\n    return this.apiService.post(\r\n      API.SITE_UPGRADE.WEBEX_BATCH_STATUS\r\n        .replace(':customerId', this.customerId),\r\n      batchIds,\r\n      false\r\n    )\r\n      .pipe(map((result: BatchStatusDTO[]) => {\r\n        this.siteUpdateStatusEvent.next(result);\r\n        return result;\r\n      }))\r\n  }\r\n\r\n  getSiteListForCollectAndBuildWebexCache(): Observable<number[]> {\r\n    return this.apiService.fetch(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION_SITE_LIST.replace(':customerId', this.customerId))\r\n      .pipe(map((siteSet: number[]) => this.siteSetForCollectAndBuildWebexCache = siteSet))\r\n  }\r\n\r\n  getCUCMListCurrentlyInCollectAndBuildWebexCache(): Observable<number[]> {\r\n    return this.apiService.fetch(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION_CUCM_LIST.replace(':customerId', this.customerId))\r\n      .pipe(\r\n        map((cucmSet: number[]) => this.cucmSetInCollectAndBuildWebexCache = cucmSet),\r\n      );\r\n  }\r\n\r\n  getMigrationBatchesStatuses(): Observable<BatchStatusDTO[]> {\r\n    return this.apiService.fetch(API.SITE_UPGRADE.BATCH_STATUS.replace(':customerId', this.customerId))\r\n      /*.pipe(map((result: BatchStatusDTO[]) => {\r\n        this.siteUpdateStatusEvent.next(result);\r\n        return result;\r\n      }))*/\r\n  }\r\n\r\n  getMigratedSiteStatus(pageSize: number, page: number): Observable<WebexMigratedSiteStatusInterface[]> {\r\n    return this.apiService.fetchPagination(\r\n      API.SITE_UPGRADE.MIGRATION_STATUS.replace(':customerId', this.customerId),\r\n      pageSize, page, {}, false\r\n    )\r\n  }\r\n\r\n  // TODO: Impl the site upgrade logic here\r\n  upgradeSite(site: SiteUpgradeRecord): void {\r\n    const customerId = site.customerId;\r\n    const siteId = site.siteId;\r\n  }\r\n}\r\n\r\nexport interface BatchStatusDTO {\r\n  id: number;\r\n  status: string;\r\n  progress: number;\r\n  migErrorsCount: string;\r\n}\r\n\r\nexport const STATUSES = {\r\n  COMPLETED: 'Completed',\r\n  NEW: 'New',\r\n  IN_PROGRESS: 'In Progress',\r\n  FAILED_IN_ERROR: 'Failed-in error',\r\n  FAILED: 'Failed',\r\n  FAILED_WITH_RETRY: 'Failed with Retry',\r\n  COLLECTING: 'Collecting',\r\n  FAILED_COLLECTING: 'Failed on collecting',\r\n  WAITING_FOR_REVIEW: 'Waiting for review'\r\n};\r\nexport interface WebexMigratedSiteStatusInterface {\r\n  site?: {id: number, name: string};\r\n  migrationFormStatus: string;\r\n}\r\nexport interface SiteMigrationProgressInterface {\r\n  id: number;\r\n  status: string;\r\n  progress: number;\r\n  migErrorsCount: number | null;\r\n}\r\n\r\nexport interface MigrationBatch {\r\n  id: number;\r\n  sourceId: number;\r\n  targetId: number;\r\n  name: string;\r\n  sourceIp: string;\r\n  sourceCucIp: string | null;\r\n  targetIp: string | null;\r\n  size: number;\r\n  status: string;\r\n  suggestedDestination: string | null;\r\n  destination: string | null;\r\n  regionName: string | null;\r\n  progress: number;\r\n  migrationProcessUUID: string | null;\r\n  customerId: number;\r\n  owner: string | null;\r\n  date: string | null;\r\n  comments: string | null;\r\n  siteId: number;\r\n  planUUID: string;\r\n  comparisonProcessUUID: string | null;\r\n  type: string;\r\n  migErrorsCount: number | null;\r\n  sourceCucId: number | null;\r\n  targetCucId: number | null;\r\n  sites: unknown | null;\r\n  serverType: string;\r\n  migrationFormId: number;\r\n  hasValidationErrors: boolean;\r\n}\r\n"]}

package/esm2020/di2mt/widgets/site-upgrade/types/user-upgrade.mjs

@@ -0,0 +1,3 @@
+;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci11cGdyYWRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHVraS93aWRnZXRzL2RpMm10L3dpZGdldHMvc2l0ZS11cGdyYWRlL3R5cGVzL3VzZXItdXBncmFkZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEwQkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFVwZ3JhZGVTdGF0dXMgfSBmcm9tIFwiLi4vLi4vLi4vc2hhcmVkL3R5cGVzL2NvbnN0YW50c1wiO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBTaXRlVXBncmFkZVJlY29yZCB7XHJcbiAgaWQ6IG51bWJlcjtcclxuICBjdXN0b21lcklkOiBzdHJpbmc7XHJcbiAgc2l0ZUlkOiBudW1iZXI7XHJcbiAgYmF0Y2hJZDogbnVtYmVyO1xyXG4gIHNpdGVOYW1lOiBzdHJpbmc7XHJcbiAgdG90YWxVc2VyczogbnVtYmVyO1xyXG4gIHRvdGFsUmVhZHlVc2VyczogbnVtYmVyO1xyXG4gIHRvdGFsTm90UmVhZHlVc2VyczogbnVtYmVyO1xyXG4gIHRvdGFsVXBncmFkZWRVc2VyczogbnVtYmVyO1xyXG4gIHRvdGFsRmFpbGVkVXNlcnM6IG51bWJlcjtcclxuICBtaWdyYXRpb25Gb3JtSWQ/OiBudW1iZXI7XHJcbiAgcHJvZ3Jlc3M/OiBudW1iZXI7XHJcbiAgbG9jYXRpb25NYXBwaW5nOiBib29sZWFuO1xyXG4gIFBTVE5UcnVuazogYm9vbGVhbjtcclxuICB1cGdyYWRlU3RhdHVzOiBVcGdyYWRlU3RhdHVzIHwgc3RyaW5nO1xyXG4gIHBlbmRpbmc/OiBib29sZWFuO1xyXG4gIGluaXRQZW5kaW5nPzogYm9vbGVhbjtcclxuICBpbnRlcnZhbD86IGFueTtcclxuICBzdGF0dXM/OiBzdHJpbmc7XHJcbiAgaXNQcm9ncmVzc0JhckF2YWlsYWJsZT86IGJvb2xlYW47XHJcbiAgaXNNaWdyYXRpb25JblByb2dyZXNzPzogYm9vbGVhbjtcclxuICBpc0NVQ01JbkNvbGxlY3RDYWNoZT86IGJvb2xlYW47XHJcbiAgaXNDb2xsZWN0ZWQ/OiBib29sZWFuO1xyXG59O1xyXG4iXX0=

package/esm2020/di2mt/widgets/upgrade-overview/cards/already-upgraded-sites/already-upgraded-sites-card.component.mjs

@@ -0,0 +1,64 @@
+import { Component, Input, inject } from "@angular/core";
+import { UpgradeOverviewService } from "../../upgrade-overview.service";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs";
+import { APIService } from "../../../../shared/services/api.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../shared/components/stat-card/stat-card.component";
+export class AlreadyUpgradedSitesCardComponent {
+    constructor() {
+        this.apiService = inject(APIService);
+        this.upgradeOverviewService = inject(UpgradeOverviewService);
+        this.destroy$ = new Subject();
+        this.title = 'Upgraded Sites';
+        this.type = 'site';
+        this.upgradeStatus = 'already';
+        this.loading = false;
+    }
+    ngOnInit() {
+        this.apiService.token = this.token;
+        this.upgradeOverviewService.customerId = this.customerId;
+        this.loading = true;
+        this.upgradeOverviewService.getSitesUpgradeSummary()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((stats) => {
+            this.readinessStats = stats;
+            this.loading = false;
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+AlreadyUpgradedSitesCardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AlreadyUpgradedSitesCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AlreadyUpgradedSitesCardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: AlreadyUpgradedSitesCardComponent, selector: "tk-already-upgraded-sites-card", inputs: { token: "token", customerId: "customerId" }, ngImport: i0, template: `
+        <tk-stat-card
+            *ngIf="!loading"
+            [title]="title"
+            [type]="type"
+            [readinessStats]="readinessStats"
+            [upgradeStatus]="upgradeStatus"
+        ></tk-stat-card>
+    `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.StatCardComponent, selector: "tk-stat-card", inputs: ["title", "type", "readinessStats", "upgradeStatus"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AlreadyUpgradedSitesCardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tk-already-upgraded-sites-card',
+                    template: `
+        <tk-stat-card
+            *ngIf="!loading"
+            [title]="title"
+            [type]="type"
+            [readinessStats]="readinessStats"
+            [upgradeStatus]="upgradeStatus"
+        ></tk-stat-card>
+    `
+                }]
+        }], propDecorators: { token: [{
+                type: Input
+            }], customerId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/di2mt/widgets/upgrade-overview/cards/already-upgraded-users/already-upgraded-users-card.component.mjs

@@ -0,0 +1,64 @@
+import { Component, Input, inject } from "@angular/core";
+import { UpgradeOverviewService } from "../../upgrade-overview.service";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs";
+import { APIService } from "../../../../shared/services/api.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../shared/components/stat-card/stat-card.component";
+export class AlreadyUpgradedUsersCardComponent {
+    constructor() {
+        this.apiService = inject(APIService);
+        this.upgradeOverviewService = inject(UpgradeOverviewService);
+        this.destroy$ = new Subject();
+        this.title = 'Upgraded Users';
+        this.type = 'user';
+        this.upgradeStatus = 'already';
+        this.loading = false;
+    }
+    ngOnInit() {
+        this.apiService.token = this.token;
+        this.upgradeOverviewService.customerId = this.customerId;
+        this.loading = true;
+        this.upgradeOverviewService.getUsersUpgradeSummary()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((stats) => {
+            this.readinessStats = stats;
+            this.loading = false;
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+AlreadyUpgradedUsersCardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AlreadyUpgradedUsersCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AlreadyUpgradedUsersCardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: AlreadyUpgradedUsersCardComponent, selector: "tk-already-upgraded-users-card", inputs: { token: "token", customerId: "customerId" }, ngImport: i0, template: `
+        <tk-stat-card
+            *ngIf="!loading"
+            [title]="title"
+            [type]="type"
+            [readinessStats]="readinessStats"
+            [upgradeStatus]="upgradeStatus"
+        ></tk-stat-card>
+    `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.StatCardComponent, selector: "tk-stat-card", inputs: ["title", "type", "readinessStats", "upgradeStatus"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AlreadyUpgradedUsersCardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tk-already-upgraded-users-card',
+                    template: `
+        <tk-stat-card
+            *ngIf="!loading"
+            [title]="title"
+            [type]="type"
+            [readinessStats]="readinessStats"
+            [upgradeStatus]="upgradeStatus"
+        ></tk-stat-card>
+    `
+                }]
+        }], propDecorators: { token: [{
+                type: Input
+            }], customerId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/di2mt/widgets/upgrade-overview/cards/preconditions-status-list/preconditions-status-list-card.component.mjs

@@ -0,0 +1,83 @@
+import { Component, inject, Input } from "@angular/core";
+import { UpgradeOverviewService } from "../../upgrade-overview.service";
+import { Subject, takeUntil } from "rxjs";
+import { APIService } from "../../../../shared/services/api.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../shared/components/status-list-card/status-list-card.component";
+export class PreconditionsStatusListCardComponent {
+    constructor() {
+        this.apiService = inject(APIService);
+        this.destroy$ = new Subject();
+        this.upgradeOverviewService = inject(UpgradeOverviewService);
+        this.title = 'Mandatory Preconditions for Upgrade';
+    }
+    ngOnInit() {
+        this.apiService.token = this.token;
+        this.upgradeOverviewService.customerId = this.customerId;
+        this.upgradeOverviewService.getUpgradePreconditions()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((resp) => {
+            this.preconditions = resp;
+            this.init();
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    init() {
+        this.items = [
+            {
+                label: 'Control Hub Integration',
+                description: 'Control Hub Connectivity',
+                status: this.preconditions.controlHubIntegration === 'CONNECTED',
+                tooltip: 'Your tenant must be connected to Webex Control Hub to enable and manage the upgrade process.',
+                link: {
+                    href: 'https://dev.tuki.io/',
+                    tooltip: 'Click below to open the integration setup wizard in Tuki. If the tenant is not yet connected, you will be redirected to create the integration in Control Hub.'
+                }
+            },
+            {
+                label: 'SIP Trunk (Local Gateway)',
+                description: 'CUCM trunk connectivity estabilished',
+                status: true,
+                tooltip: 'CUCM must have an active SIP trunk to the Local Gateway for tenant-wide external calling.',
+                link: {
+                    href: 'https://dev.tuki.io/',
+                    tooltip: 'Confirm that the trunk is configured and connected in CUCM.'
+                }
+            },
+            {
+                label: `${this.preconditions.numberOfAvailableLicences} Available User Licences`,
+                description: 'Webex calling licences provisioned and assgined',
+                status: this.preconditions.numberOfAvailableLicences > 0,
+                tooltip: 'Webex Calling licenses are required for users who are being upgraded.',
+                link: {
+                    href: '',
+                    tooltip: ''
+                }
+            }
+        ];
+    }
+}
+PreconditionsStatusListCardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PreconditionsStatusListCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+PreconditionsStatusListCardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: PreconditionsStatusListCardComponent, selector: "tk-preconditions-status-list-card", inputs: { token: "token", customerId: "customerId" }, ngImport: i0, template: `
+        <tk-status-list-card 
+            [title]="title"
+            [items]="items"
+        ></tk-status-list-card>
+    `, isInline: true, styles: [":host{width:100%}\n"], dependencies: [{ kind: "component", type: i1.StatusListCardComponent, selector: "tk-status-list-card", inputs: ["title", "items"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: PreconditionsStatusListCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tk-preconditions-status-list-card', template: `
+        <tk-status-list-card 
+            [title]="title"
+            [items]="items"
+        ></tk-status-list-card>
+    `, styles: [":host{width:100%}\n"] }]
+        }], propDecorators: { token: [{
+                type: Input
+            }], customerId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/di2mt/widgets/upgrade-overview/cards/ready-to-upgrade-sites/ready-to-upgrade-sites-card.component.mjs

@@ -0,0 +1,45 @@
+import { Component, Input, inject } from "@angular/core";
+import { UpgradeOverviewService } from "../../upgrade-overview.service";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs";
+import { APIService } from "../../../../shared/services/api.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../shared/components/stat-card/stat-card.component";
+export class ReadyToUpgradeSitesCardComponent {
+    constructor() {
+        this.apiService = inject(APIService);
+        this.upgradeOverviewService = inject(UpgradeOverviewService);
+        this.destroy$ = new Subject();
+        this.title = 'Ready Sites';
+        this.type = 'site';
+        this.upgradeStatus = 'ready';
+        this.loading = false;
+    }
+    ngOnInit() {
+        this.apiService.token = this.token;
+        this.upgradeOverviewService.customerId = this.customerId;
+        this.loading = true;
+        this.upgradeOverviewService.getSitesUpgradeReadiness()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((stats) => {
+            this.readinessStats = stats;
+            this.loading = false;
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+ReadyToUpgradeSitesCardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ReadyToUpgradeSitesCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ReadyToUpgradeSitesCardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: ReadyToUpgradeSitesCardComponent, selector: "tk-ready-to-upgrade-sites-card", inputs: { token: "token", customerId: "customerId" }, ngImport: i0, template: "  <tk-stat-card\r\n    *ngIf=\"!loading\"\r\n    [title]=\"title\"\r\n    [type]=\"type\"\r\n    [readinessStats]=\"readinessStats\"\r\n    [upgradeStatus]=\"upgradeStatus\">\r\n  </tk-stat-card>", styles: [""], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.StatCardComponent, selector: "tk-stat-card", inputs: ["title", "type", "readinessStats", "upgradeStatus"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ReadyToUpgradeSitesCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tk-ready-to-upgrade-sites-card', template: "  <tk-stat-card\r\n    *ngIf=\"!loading\"\r\n    [title]=\"title\"\r\n    [type]=\"type\"\r\n    [readinessStats]=\"readinessStats\"\r\n    [upgradeStatus]=\"upgradeStatus\">\r\n  </tk-stat-card>" }]
+        }], propDecorators: { token: [{
+                type: Input
+            }], customerId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/di2mt/widgets/upgrade-overview/cards/ready-to-upgrade-users/ready-to-upgrade-users-card.component.mjs

@@ -0,0 +1,45 @@
+import { Component, Input, inject } from "@angular/core";
+import { UpgradeOverviewService } from "../../upgrade-overview.service";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs";
+import { APIService } from "../../../../shared/services/api.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../../shared/components/stat-card/stat-card.component";
+export class ReadyToUpgradeUsersCardComponent {
+    constructor() {
+        this.apiService = inject(APIService);
+        this.upgradeOverviewService = inject(UpgradeOverviewService);
+        this.destroy$ = new Subject();
+        this.title = 'Ready Users';
+        this.type = 'user';
+        this.upgradeStatus = 'ready';
+        this.loading = false;
+    }
+    ngOnInit() {
+        this.apiService.token = this.token;
+        this.upgradeOverviewService.customerId = this.customerId;
+        this.loading = true;
+        this.upgradeOverviewService.getUsersUpgradeReadiness()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((stats) => {
+            this.readinessStats = stats;
+            this.loading = false;
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+ReadyToUpgradeUsersCardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ReadyToUpgradeUsersCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ReadyToUpgradeUsersCardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: ReadyToUpgradeUsersCardComponent, selector: "tk-ready-to-upgrade-users-card", inputs: { token: "token", customerId: "customerId" }, ngImport: i0, template: "  <tk-stat-card\r\n    *ngIf=\"!loading\"\r\n    [title]=\"title\"\r\n    [type]=\"type\"\r\n    [readinessStats]=\"readinessStats\"\r\n    [upgradeStatus]=\"upgradeStatus\">\r\n  </tk-stat-card>", styles: [""], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.StatCardComponent, selector: "tk-stat-card", inputs: ["title", "type", "readinessStats", "upgradeStatus"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ReadyToUpgradeUsersCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tk-ready-to-upgrade-users-card', template: "  <tk-stat-card\r\n    *ngIf=\"!loading\"\r\n    [title]=\"title\"\r\n    [type]=\"type\"\r\n    [readinessStats]=\"readinessStats\"\r\n    [upgradeStatus]=\"upgradeStatus\">\r\n  </tk-stat-card>" }]
+        }], propDecorators: { token: [{
+                type: Input
+            }], customerId: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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