@tuki-io/tuki-widgets 0.0.95 → 0.0.97

package/projects/tuki/widgets/di2mt/widgets/site-upgrade/site-upgrade-data-table/site-upgrade-data-table.component.ts

@@ -0,0 +1,506 @@
+import { SelectionModel } from "@angular/cdk/collections";
+import { Component, OnInit, OnDestroy, inject, Input, ViewEncapsulation } from "@angular/core";
+import { MatTableDataSource } from "@angular/material/table";
+import { TableColumn } from "../../../shared/types/data-table";
+import { TableFilter } from "../../../shared/types/table/filter";
+import { SiteUpgradeRecord } from "../types/user-upgrade";
+import { UpgradeOverviewService } from "../../upgrade-overview/upgrade-overview.service";
+import { forkJoin, of, Subject, Subscription } from "rxjs";
+import { takeUntil } from "rxjs";
+import {
+  BatchStatusDTO, MigrationBatch,
+  SiteUpgradeService,
+  STATUSES,
+  WebexMigratedSiteStatusInterface
+} from "../site-upgrade.service";
+import { STATUS_ENTRIES } from "../../../shared/types/constants";
+import { APIService } from "../../../shared/services/api.service";
+import { catchError, map } from 'rxjs/operators';
+
+const MAX_INTEGER = 2147483647;
+@Component({
+  selector: 'tk-site-upgrade-data-table',
+  templateUrl: './site-upgrade-data-table.component.html',
+  styleUrls: ['./site-upgrade-data-table.component.scss'],
+  encapsulation: ViewEncapsulation.None
+})
+export class SiteUpgradeDataTableComponent implements OnInit, OnDestroy {
+  readonly siteUpgradeService = inject(SiteUpgradeService);
+  private readonly apiService = inject(APIService);
+  readonly destroy$ = new Subject<void>();
+  readonly STATUS_ENTRIES = STATUS_ENTRIES;
+
+  @Input() token!: string;
+  @Input() customerId!: string;
+
+  columns!: TableColumn[];
+  dataPending = false;
+  data!: MatTableDataSource<any>;
+  displayedColumns: string[] = ['site', 'ready users', 'upgraded users', 'location mapping', 'pstn trunk', 'site upgrade status', 'progressBar', 'actions', 'userUpgradeLoader'];
+  selection = new SelectionModel<any>(true, []);
+  filters: TableFilter[] = [];
+  private activeFilters: { [key: string]: any } = {};
+  private subscriptions = new Subscription();
+  private collectingBatchInterval: any;
+
+  statusCounts: any = {};
+
+  constructor() {
+  }
+
+  ngOnInit(): void {
+    this.dataPending = true;
+    this.apiService.token = this.token;
+    this.siteUpgradeService.customerId = this.customerId;
+
+    const subsc1 = forkJoin([
+      this.siteUpgradeService.getSiteUpgradeRecords(),
+      this.siteUpgradeService.getMigratedSiteStatus(MAX_INTEGER, 0),
+      this.siteUpgradeService.getSiteListForCollectAndBuildWebexCache(),
+      this.siteUpgradeService.getCUCMListCurrentlyInCollectAndBuildWebexCache(),
+      this.siteUpgradeService.getBatchSites()
+    ]).pipe(takeUntil(this.destroy$))
+      .subscribe((results: [SiteUpgradeRecord[], WebexMigratedSiteStatusInterface[], number[], number[], MigrationBatch[]]) => {
+        const records = results[0].map(site => ({
+          ...site,
+          siteId: Number(site.siteId)
+        }));
+        this.data = new MatTableDataSource<SiteUpgradeRecord>(records);
+        this.dataPending = false;
+        this.setupCustomFilter();
+        this.initializeFilters(records);
+
+        this.setMigratedStatus(results[1]);
+
+        if (this.data?.data.length && results[2]?.length) {
+          this.initCollectProgress(results[2]);
+        }
+        if (this.data?.data.length && results[4]?.length) {
+          this.setBatchIdToSites(results[4]);
+        }
+      });
+    this.subscriptions.add(subsc1);
+
+    const subsc2 = this.siteUpgradeService.getSiteUpgradeStatusCounts()
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((statusCounts) => {
+        this.statusCounts['Ready'] = statusCounts['READY'] || 0;
+        this.statusCounts['Not Ready'] = statusCounts['NOT_READY'] || 0;
+        this.statusCounts['Completed'] = statusCounts['COMPLETED'] || 0;
+        this.statusCounts['Failed'] = statusCounts['FAILED'] || 0;
+      });
+    this.subscriptions.add(subsc2);
+
+    const subsc3 = this.siteUpgradeService.siteUpdateStatusEvent
+      .subscribe((updatedStatuses: BatchStatusDTO[]) => {
+        this.handleCheckBatchStatusResponse(updatedStatuses);
+      });
+    this.subscriptions.add(subsc3);
+  }
+
+  onSiteMigration(site: SiteUpgradeRecord): void {
+    site.pending = true;
+    site.isProgressBarAvailable = true;
+    site.isMigrationInProgress = true;
+    const subsc = this.siteUpgradeService.migrateSite(String(site.siteId), String(site.batchId))
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((migrationFormId: number) => {
+        site.migrationFormId = migrationFormId;
+        site.progress = 1;
+        this.runMigrationProgress(site);
+      });
+    this.subscriptions.add(subsc);
+
+  }
+
+  private runMigrationProgress(site: SiteUpgradeRecord): void {
+    this.updateMigrationProgress(site);
+
+    site.interval = setInterval(() => {
+      this.updateMigrationProgress(site);
+    }, 10000);
+
+  }
+
+  private updateMigrationProgress(site: SiteUpgradeRecord): void {
+    if (!site || !site.isMigrationInProgress) {
+      return;
+    }
+    this.siteUpgradeService.getMigrationBatchesStatuses()
+      .subscribe(
+        (statuses: BatchStatusDTO[]) => {
+          if (statuses?.length) {
+            statuses.forEach((statusItem: BatchStatusDTO) => {
+              const ind = this.getSiteIndex(statusItem.id);
+              if (ind > -1) {
+                this.data.data[ind].progress = statusItem.progress;
+                this.data.data[ind].status = statusItem.status;
+                if (statusItem.status !== 'In Progress') {
+                  this.data.data[ind].pending = false;
+                  this.data.data[ind].isMigrationInProgress = false;
+                  this.data.data[ind].isProgressBarAvailable = false;
+                }
+              }
+            });
+            if (statuses.filter(statusItem => statusItem.status === 'In Progress').length < 1) {
+              this.data.data.forEach(site => {
+                site.pending = false;
+                site.isMigrationInProgress = false;
+                site.isProgressBarAvailable = false;
+              })
+            }
+          }
+
+        },
+        () => {
+          this.resetMigrationProgress(site, 'FAILED');
+        }
+      );
+  }
+
+  private resetMigrationProgress(site: SiteUpgradeRecord, status?: string): void {
+    site.isMigrationInProgress = false;
+    site.pending = false;
+    site.isProgressBarAvailable = false;
+    if (site.interval) {
+      clearInterval(site.interval);
+    }
+    if (status) {
+      site.status = status;
+    }
+  }
+
+  public onCollect(site: SiteUpgradeRecord): void {
+    site.pending = true;
+    site.status = STATUSES.COLLECTING;
+    // const ind =
+    const subscription =
+      this.siteUpgradeService.collectSiteCache(Number(site.siteId), 'webex')
+        .subscribe({
+          error: () => site.pending = false
+        });
+    this.subscriptions.add(subscription);
+    /*setTimeout(() => {
+      this.runBatchCheckStatus();
+    }, 700);*/
+    setTimeout(() => {
+      this.initCollectInterval(site);
+    }, 700);
+  }
+
+  private initCollectInterval(site: SiteUpgradeRecord): void {
+    if (!site.interval && !site.initPending) {
+      site.initPending = true;
+
+      this.getCUCMListAlreadyInCollectWebexCache(site);
+      this.getSiteListForCollectAndBuildWebexCache(site);
+
+      site.interval = setInterval(() => {
+        this.getCUCMListAlreadyInCollectWebexCache(site);
+        this.getSiteListForCollectAndBuildWebexCache(site);
+
+      }, 10000);
+    }
+  }
+
+  private getSiteListForCollectAndBuildWebexCache(site: SiteUpgradeRecord): void {
+    this.siteUpgradeService.getSiteListForCollectAndBuildWebexCache()
+      .pipe(takeUntil(this.destroy$))
+      .subscribe((siteSet: number[]) => {
+        if (!siteSet || !siteSet.length) {
+          site.pending = false;
+          this.removeInterval(site);
+          site.isCollected = true;
+        }
+      }, () => {
+        site.pending = false;
+        this.removeInterval(site);
+      });
+  }
+
+  private removeInterval(site: SiteUpgradeRecord): void {
+    if (site.interval) {
+      clearInterval(site.interval);
+    }
+  }
+
+  private handleBatchCUCMAlreadyInCollectCache(): void {
+    this.data.data.forEach(site => {
+      site.isCUCMInCollectCache =
+        this.siteUpgradeService?.cucmSetInCollectAndBuildWebexCache?.includes(Number(site.sourceId));
+    });
+  }
+
+  private getCUCMListAlreadyInCollectWebexCache(site: SiteUpgradeRecord): void {
+    this.siteUpgradeService.getCUCMListCurrentlyInCollectAndBuildWebexCache()
+      .pipe(takeUntil(this.destroy$))
+      .pipe(map((cucmList: any) => {
+        this.handleBatchCUCMAlreadyInCollectCache();
+        if (!cucmList || !cucmList.length) {
+          site.pending = false;
+          this.removeInterval(site);
+          site.isCollected = true;
+        }
+        return cucmList;
+      })
+      ).subscribe({
+      error: () => {
+        site.pending = false;
+        site.initPending = true;
+        this.removeInterval(site);
+      }
+    });
+  }
+
+  private checkBatchStatus(batchIds: string[]): void {
+    const subsc = this.siteUpgradeService.getBatchesStatuses(batchIds)
+      .pipe(
+        takeUntil(this.destroy$),
+        catchError(() => {
+          clearInterval(this.collectingBatchInterval);
+          return of([]);
+        })
+      ).subscribe((updatedStatuses: BatchStatusDTO[]) => {
+        this.handleCheckBatchStatusResponse(updatedStatuses);
+      });
+    this.subscriptions.add(subsc);
+  }
+
+  private handleCheckBatchStatusResponse(updatedStatuses: BatchStatusDTO[]): void {
+    if (updatedStatuses && updatedStatuses.length && this.data?.data?.length) {
+      updatedStatuses.forEach(updatedStatus => {
+        const ind = this.data?.data.findIndex(batch => batch.siteId === updatedStatus.id);
+        if (ind > -1 && this.data?.data[ind] && updatedStatus.status) {
+          this.data.data[ind].upgradeStatus = updatedStatus.status;
+        }
+      });
+    } else {
+      if (this.collectingBatchInterval) {
+        clearInterval(this.collectingBatchInterval);
+      }
+    }
+  }
+
+  private getSiteIndex(batchId: number): number {
+    if (this.data.data.length) {
+      return this.data.data.findIndex(siteItem => siteItem.batchId === batchId);
+    }
+    return -1;
+  }
+
+  private initializeFilters(records: SiteUpgradeRecord[]): void {
+    if (!records?.length) {
+      this.filters = [];
+      return;
+    }
+
+    // Extract unique sites (skip empty/null)
+    const uniqueSites = [
+      ...new Set(
+        records
+          .map(record => record.siteName?.trim())
+          .filter((site): site is string => !!site)
+      )
+    ];
+
+    const siteOptions = uniqueSites.map(site => ({
+      label: site,
+      value: site.toLowerCase().replace(/\s+/g, '-')
+    }));
+
+    // Extract unique statuses (skip empty/null)
+    const uniqueStatuses = [
+      ...new Set(
+        records
+          .map(record => record.upgradeStatus?.trim())
+          .filter((status): status is string => !!status)
+      )
+    ];
+
+    const statusOptions = uniqueStatuses.map(status => ({
+      label: STATUS_ENTRIES[status],
+      value: status.toLowerCase().replace(/\s+/g, '-')
+    }));
+
+    this.filters = [];
+
+    if (siteOptions.length) {
+      this.filters.push({
+        id: 'sites',
+        type: 'select',
+        columnKey: 'Site',
+        placeholder: 'Sites',
+        options: siteOptions
+      });
+    }
+
+    if (statusOptions.length) {
+      this.filters.push({
+        id: 'status',
+        type: 'select',
+        columnKey: 'Site Upgrade Status',
+        placeholder: 'Upgrade Status',
+        options: statusOptions
+      });
+    }
+  }
+
+
+  onFilter(filterEvent: { key: string, value: any }) {
+    const {key, value} = filterEvent;
+
+    let filterValue: any;
+    if (value && value.value !== undefined) {
+      filterValue = value.value;
+    } else if (value && value.target) {
+      filterValue = value.target.value;
+    } else {
+      filterValue = value;
+    }
+
+    // Handle "All" option or empty values - remove the filter
+    if (filterValue === 'all' || !filterValue || filterValue === '') {
+      delete this.activeFilters[key];
+    } else {
+      this.activeFilters[key] = filterValue;
+    }
+
+    this.applyFilters();
+  }
+
+  private setupCustomFilter() {
+    this.data.filterPredicate = (data: any, filter: string) => {
+      const filters = JSON.parse(filter || '{}');
+
+      for (const [key, value] of Object.entries(filters)) {
+        if (!value) continue;
+
+        switch (key) {
+          case 'Site':
+            if (data.siteName !== this.getSiteNameFromValue(value as string)) {
+              return false;
+            }
+            break;
+          case 'Site Upgrade Status':
+            if (!this.matchesUpgradeStatus(data.upgradeStatus, value as string)) {
+              return false;
+            }
+            break;
+        }
+      }
+
+      return true;
+    };
+  }
+
+  private applyFilters() {
+    this.data.filter = JSON.stringify(this.activeFilters);
+  }
+
+  private getSiteNameFromValue(value: string): string {
+    // Since we're now using actual site names, just convert back from slug format
+    return value.split('-').map(word =>
+      word.charAt(0).toUpperCase() + word.slice(1)
+    ).join(' ');
+  }
+
+  private matchesUpgradeStatus(status: string, filterValue: string): boolean {
+    // Handle direct status matching for cleaner implementation
+    return status.toLowerCase().replace(/\s+/g, '-') === filterValue.toLowerCase();
+  }
+
+  get filteredDataCount(): number {
+    return this.data?.filteredData?.length || 0;
+  }
+
+  /** Whether the number of selected elements matches the total number of rows. */
+  isAllSelected() {
+    const numSelected = this.selection.selected.length;
+    const numRows = this.data?.data.length || 0;
+    return numSelected === numRows;
+  }
+
+  /** Selects all rows if they are not all selected; otherwise clear selection. */
+  masterToggle() {
+    this.isAllSelected() ?
+      this.selection.clear() :
+      this.data?.data.forEach(row => this.selection.select(row));
+  }
+
+  getLocationMappingClass(locationMapping: boolean): string {
+    return locationMapping ? 'success' : 'error';
+  }
+
+  getSiteUpgradeStatusClass(status: string): string {
+    switch (status.toLowerCase()) {
+      case 'ready':
+        return 'status-ready';
+      case 'partial ready':
+        return 'partial-ready';
+      case 'completed':
+        return 'completed';
+      case 'failed':
+        return 'failed';
+      case 'not ready':
+        return 'not-ready';
+      default:
+        return 'not-ready';
+    }
+  }
+
+  upgradeSite(site: SiteUpgradeRecord) {
+    this.siteUpgradeService.upgradeSite(site);
+  }
+
+  private setMigratedStatus(webexMigratedSites: WebexMigratedSiteStatusInterface[]): void {
+    if (webexMigratedSites && webexMigratedSites.length && this.data?.data?.length) {
+      const statusObj = this.getSiteStatusMappingObj(webexMigratedSites);
+      this.data.data.forEach(site => site.migrationFormStatus = statusObj[site.siteId] || '');
+    }
+  }
+
+  private getSiteStatusMappingObj(webexMigratedSites: WebexMigratedSiteStatusInterface[]): any {
+    const statusObj: any = {};
+    webexMigratedSites.forEach(item => {
+      if (item.site?.id) {
+        statusObj[String(item.site.id)] = item.migrationFormStatus;
+      }
+    });
+    return statusObj;
+  }
+
+  private setBatchIdToSites(batches: MigrationBatch[]): void {
+    if (this.data?.data?.length) {
+      this.data.data.forEach(site => {
+        site.batchId = this.getBatchId(batches, site.siteId);
+      });
+    }
+  }
+
+  private getBatchId(batches: MigrationBatch[], siteId: number): number | null {
+    const ind = batches.findIndex(batch => batch.siteId === siteId);
+    return ind > -1 ? batches[ind].id : null;
+  }
+
+  private initCollectProgress(sitesInProgress: number[]): void {
+    this.data?.data.forEach(site => {
+      if (sitesInProgress.includes(site.siteId)) {
+        site.pending = true;
+        this.initCollectInterval(site);
+      }
+    });
+  }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+    this.dataPending = false;
+
+    if (this.collectingBatchInterval) {
+      clearInterval(this.collectingBatchInterval);
+    }
+    if (this.subscriptions) {
+      this.subscriptions.unsubscribe();
+    }
+  }
+}

package/projects/tuki/widgets/di2mt/widgets/site-upgrade/site-upgrade.module.ts

@@ -0,0 +1,33 @@
+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';
+
+@NgModule({
+  declarations: [
+    SiteUpgradeDataTableComponent,
+    ProgressBarComponent
+  ],
+  imports: [
+    CommonModule,
+    SharedModule,
+    MatTableModule,
+    MatIconModule,
+    MatMenuModule,
+    MatButtonModule,
+    MatProgressSpinnerModule
+
+  ],
+  exports: [
+    SiteUpgradeDataTableComponent,
+    ProgressBarComponent
+  ]
+})
+export class SiteUpgradeModule {
+}

package/projects/tuki/widgets/di2mt/widgets/site-upgrade/site-upgrade.service.ts

@@ -0,0 +1,172 @@
+import { inject, Injectable } from "@angular/core";
+import { map, Observable, Subject } from "rxjs";
+import { SiteUpgradeRecord } from "./types/user-upgrade";
+import { API } from "../../api/api.endpoints";
+import { UserUpgradeRecord } from "../user-upgrade/types/user-upgrade";
+import { APIService } from "../../shared/services/api.service";
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SiteUpgradeService {
+  siteSetForCollectAndBuildWebexCache: number[] | undefined;
+  cucmSetInCollectAndBuildWebexCache: number[] | undefined;
+  siteUpdateStatusEvent = new Subject<BatchStatusDTO[]>();
+  private apiService = inject(APIService);
+  customerId!: string;
+
+  getSiteUpgradeStatusCounts(): Observable<any> {
+    return this.apiService.fetch(
+      API.SITE_UPGRADE.GET_SITES_UPGRADE_STATUS_COUNTS.replace(':customerId', this.customerId)
+    );
+  }
+
+  getSiteUpgradeRecords(): Observable<SiteUpgradeRecord[]> {
+    return this.apiService.fetch(
+      API.SITE_UPGRADE.GET_SITES_UPGRADE_DATA.replace(':customerId', this.customerId)
+    ).pipe(map((resp) => {
+      return resp.content.map((record: any) => ({
+        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
+      } as SiteUpgradeRecord));
+    }));
+  }
+
+  getBatchSites(): Observable<MigrationBatch[]> {
+    return this.apiService.fetch(
+      API.SITE_UPGRADE.GET_BATCH_SITES.replace(':customerId', this.customerId)
+    );
+  }
+
+  collectSiteCache(siteId: number, migrationType: string = 'webex') {
+    return this.apiService.post(
+      API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION
+        .replace(':siteId', String(siteId))
+        .replace(':migrationType', migrationType),
+      {}
+    )
+  }
+
+  migrateSite(siteId: string, batchId: string): Observable<any> {
+    return this.apiService.post(
+      API.SITE_UPGRADE.MIGRATE_SITE.replace(':siteId', String(siteId)),
+      {},
+      {batchId: batchId || ''}
+    )
+  }
+
+  getBatchesStatuses(batchIds: string[]): Observable<BatchStatusDTO[]> {
+    return this.apiService.post(
+      API.SITE_UPGRADE.WEBEX_BATCH_STATUS
+        .replace(':customerId', this.customerId),
+      batchIds,
+      false
+    )
+      .pipe(map((result: BatchStatusDTO[]) => {
+        this.siteUpdateStatusEvent.next(result);
+        return result;
+      }))
+  }
+
+  getSiteListForCollectAndBuildWebexCache(): Observable<number[]> {
+    return this.apiService.fetch(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION_SITE_LIST.replace(':customerId', this.customerId))
+      .pipe(map((siteSet: number[]) => this.siteSetForCollectAndBuildWebexCache = siteSet))
+  }
+
+  getCUCMListCurrentlyInCollectAndBuildWebexCache(): Observable<number[]> {
+    return this.apiService.fetch(API.SITE_UPGRADE.WEBEX_CACHE_COLLECTION_CUCM_LIST.replace(':customerId', this.customerId))
+      .pipe(
+        map((cucmSet: number[]) => this.cucmSetInCollectAndBuildWebexCache = cucmSet),
+      );
+  }
+
+  getMigrationBatchesStatuses(): Observable<BatchStatusDTO[]> {
+    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: number, page: number): Observable<WebexMigratedSiteStatusInterface[]> {
+    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: SiteUpgradeRecord): void {
+    const customerId = site.customerId;
+    const siteId = site.siteId;
+  }
+}
+
+export interface BatchStatusDTO {
+  id: number;
+  status: string;
+  progress: number;
+  migErrorsCount: string;
+}
+
+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'
+};
+export interface WebexMigratedSiteStatusInterface {
+  site?: {id: number, name: string};
+  migrationFormStatus: string;
+}
+export interface SiteMigrationProgressInterface {
+  id: number;
+  status: string;
+  progress: number;
+  migErrorsCount: number | null;
+}
+
+export interface MigrationBatch {
+  id: number;
+  sourceId: number;
+  targetId: number;
+  name: string;
+  sourceIp: string;
+  sourceCucIp: string | null;
+  targetIp: string | null;
+  size: number;
+  status: string;
+  suggestedDestination: string | null;
+  destination: string | null;
+  regionName: string | null;
+  progress: number;
+  migrationProcessUUID: string | null;
+  customerId: number;
+  owner: string | null;
+  date: string | null;
+  comments: string | null;
+  siteId: number;
+  planUUID: string;
+  comparisonProcessUUID: string | null;
+  type: string;
+  migErrorsCount: number | null;
+  sourceCucId: number | null;
+  targetCucId: number | null;
+  sites: unknown | null;
+  serverType: string;
+  migrationFormId: number;
+  hasValidationErrors: boolean;
+}