backups.component.ts raw

   1  import { Component, inject, OnInit } from '@angular/core';
   2  import { Router } from '@angular/router';
   3  import {
   4    ConfirmComponent,
   5    LoggerService,
   6    NavComponent,
   7    SignerMetaData_VaultSnapshot,
   8    StartupService,
   9  } from '@common';
  10  import { getNewStorageServiceConfig } from '../../../common/data/get-new-storage-service-config';
  11  
  12  @Component({
  13    selector: 'app-backups',
  14    templateUrl: './backups.component.html',
  15    styleUrl: './backups.component.scss',
  16    imports: [ConfirmComponent],
  17  })
  18  export class BackupsComponent extends NavComponent implements OnInit {
  19    readonly #router = inject(Router);
  20    readonly #startup = inject(StartupService);
  21    readonly #logger = inject(LoggerService);
  22  
  23    backups: SignerMetaData_VaultSnapshot[] = [];
  24    maxBackups = 5;
  25    restoringBackupId: string | null = null;
  26  
  27    ngOnInit(): void {
  28      this.loadBackups();
  29      this.maxBackups = this.storage.getSignerMetaHandler().getMaxBackups();
  30    }
  31  
  32    loadBackups(): void {
  33      this.backups = this.storage.getSignerMetaHandler().getBackups();
  34    }
  35  
  36    async onMaxBackupsChange(event: Event): Promise<void> {
  37      const input = event.target as HTMLInputElement;
  38      const value = parseInt(input.value, 10);
  39      if (!isNaN(value) && value >= 1 && value <= 20) {
  40        this.maxBackups = value;
  41        await this.storage.getSignerMetaHandler().setMaxBackups(value);
  42      }
  43    }
  44  
  45    async createManualBackup(): Promise<void> {
  46      const browserSyncData = this.storage.getBrowserSyncHandler().browserSyncData;
  47      if (browserSyncData) {
  48        await this.storage.getSignerMetaHandler().createBackup(browserSyncData, 'manual');
  49        this.loadBackups();
  50      }
  51    }
  52  
  53    async restoreBackup(backupId: string): Promise<void> {
  54      this.restoringBackupId = backupId;
  55      try {
  56        // First, create a pre-restore backup of current state
  57        const currentData = this.storage.getBrowserSyncHandler().browserSyncData;
  58        if (currentData) {
  59          await this.storage.getSignerMetaHandler().createBackup(currentData, 'pre-restore');
  60        }
  61  
  62        // Get the backup data
  63        const backupData = this.storage.getSignerMetaHandler().getBackupData(backupId);
  64        if (!backupData) {
  65          throw new Error('Backup not found');
  66        }
  67  
  68        // Import the backup
  69        await this.storage.deleteVault(true);
  70        await this.storage.importVault(backupData);
  71        this.#logger.logVaultImport('Backup Restore');
  72        this.storage.isInitialized = false;
  73        this.#startup.startOver(getNewStorageServiceConfig());
  74      } catch (error) {
  75        console.error('Failed to restore backup:', error);
  76        this.restoringBackupId = null;
  77      }
  78    }
  79  
  80    async deleteBackup(backupId: string): Promise<void> {
  81      await this.storage.getSignerMetaHandler().deleteBackup(backupId);
  82      this.loadBackups();
  83    }
  84  
  85    formatDate(isoDate: string): string {
  86      const date = new Date(isoDate);
  87      return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
  88    }
  89  
  90    getReasonLabel(reason?: string): string {
  91      switch (reason) {
  92        case 'auto':
  93          return 'Auto';
  94        case 'manual':
  95          return 'Manual';
  96        case 'pre-restore':
  97          return 'Pre-Restore';
  98        default:
  99          return 'Unknown';
 100      }
 101    }
 102  
 103    getReasonClass(reason?: string): string {
 104      switch (reason) {
 105        case 'auto':
 106          return 'reason-auto';
 107        case 'manual':
 108          return 'reason-manual';
 109        case 'pre-restore':
 110          return 'reason-prerestore';
 111        default:
 112          return '';
 113      }
 114    }
 115  
 116    goBack(): void {
 117      this.#router.navigateByUrl('/home/settings');
 118    }
 119  
 120    async onClickLock(): Promise<void> {
 121      this.#logger.logVaultLock();
 122      await this.storage.lockVault();
 123      this.#router.navigateByUrl('/vault-login');
 124    }
 125  }
 126