@microsoft/windows-admin-center-sdk/core/performance/performance-profile-database.js

Microsoft - Windows Admin Center Shell

import { Observable, of } from 'rxjs';
import { share, switchMap, tap } from 'rxjs/operators';
export class PerformanceProfileDatabase {
    static databaseName = 'MsftSmePerformance';
    static objectStoreName = 'Performance';
    static version = 1;
    database;
    databaseShared;
    lastError;
    write(record) {
        return this.getDatabase()
            .pipe(switchMap(database => this.storeData(database, record)));
    }
    read(from) {
        return this.getDatabase()
            .pipe(switchMap(database => this.restoreData(database, from)));
    }
    delete(primaryKeys) {
        return this.getDatabase()
            .pipe(switchMap(database => this.deleteData(database, primaryKeys)));
    }
    close() {
        if (!this.database) {
            return;
        }
        this.database.close();
        this.database = null;
        this.databaseShared = null;
    }
    deleteAll() {
        return this.getDatabase()
            .pipe(tap(() => this.close()), switchMap(() => this.deleteDatabase()));
    }
    deleteDatabase() {
        return new Observable(observer => {
            const request = window.indexedDB.deleteDatabase(PerformanceProfileDatabase.databaseName);
            request.onerror = () => {
                observer.error(request.error);
            };
            request.onsuccess = () => {
                this.database = null;
                this.databaseShared = null;
                observer.next(null);
                observer.complete();
            };
        });
    }
    getDatabase() {
        if (this.database) {
            return of(this.database);
        }
        if (this.databaseShared) {
            return this.databaseShared;
        }
        this.databaseShared = new Observable(observer => {
            const openRequest = window.indexedDB.open(PerformanceProfileDatabase.databaseName, PerformanceProfileDatabase.version);
            openRequest.onerror = () => {
                this.lastError = openRequest.error;
                observer.error(this.lastError);
                openRequest.onerror = null;
            };
            openRequest.onsuccess = () => {
                this.database = openRequest.result;
                observer.next(this.database);
                observer.complete();
            };
            openRequest.onupgradeneeded = event => {
                const database = openRequest.result;
                database.onerror = event2 => {
                    this.lastError = event2;
                    observer.error(this.lastError);
                };
                if (event.oldVersion !== 0 && event.oldVersion < PerformanceProfileDatabase.version) {
                    database.deleteObjectStore(PerformanceProfileDatabase.objectStoreName);
                }
                database.createObjectStore(PerformanceProfileDatabase.objectStoreName, { autoIncrement: true });
            };
        })
            .pipe(share());
        return this.databaseShared;
    }
    storeData(database, record) {
        return new Observable(observer => {
            const transaction = database.transaction([PerformanceProfileDatabase.objectStoreName], 'readwrite');
            transaction.oncomplete = () => {
                observer.complete();
            };
            transaction.onerror = () => {
                observer.error(transaction.error);
            };
            const objectStore = transaction.objectStore(PerformanceProfileDatabase.objectStoreName);
            objectStore.add(record);
        });
    }
    restoreData(database, from) {
        return new Observable(observer => {
            const transaction = database.transaction([PerformanceProfileDatabase.objectStoreName], 'readonly');
            const objectStore = transaction.objectStore(PerformanceProfileDatabase.objectStoreName);
            let cursor;
            if (from) {
                const query = IDBKeyRange.lowerBound(from, true);
                cursor = objectStore.openCursor(query, 'next');
            }
            else {
                cursor = objectStore.openCursor();
            }
            cursor.onsuccess = event => {
                const current = event.target.result;
                if (current && current.value) {
                    const record = current.value;
                    record.primaryKey = current.primaryKey;
                    observer.next(record);
                    current.continue();
                }
                else {
                    observer.complete();
                }
            };
            cursor.onerror = () => {
                observer.error(cursor.error);
            };
        });
    }
    deleteData(database, primaryKeys) {
        return new Observable(observer => {
            const transaction = database.transaction([PerformanceProfileDatabase.objectStoreName], 'readwrite');
            transaction.oncomplete = () => {
                observer.complete();
            };
            transaction.onerror = () => {
                observer.error(transaction.error);
            };
            const objectStore = transaction.objectStore(PerformanceProfileDatabase.objectStoreName);
            for (const primaryKey of primaryKeys) {
                objectStore.delete(primaryKey);
            }
        });
    }
}

//# sourceMappingURL=performance-profile-database.js.map