mirror of
https://github.com/bitwarden/jslib
synced 2026-01-07 11:03:13 +00:00
55691be56b
Until this point the account model has been very flat, holding many kinds of data. In order to be able to prune data at appropriate times, for example clearing keys at logout without clearing QoL settings like locale, the Account model has been divided into logical chunks.
1426 lines
79 KiB
TypeScript
1426 lines
79 KiB
TypeScript
import { StateService as StateServiceAbstraction } from '../abstractions/state.service';
|
|
|
|
import { Account } from '../models/domain/account';
|
|
|
|
import { LogService } from '../abstractions/log.service';
|
|
import { StorageService } from '../abstractions/storage.service';
|
|
|
|
import { AuthenticationStatus } from '../enums/authenticationStatus';
|
|
import { HtmlStorageLocation } from '../enums/htmlStorageLocation';
|
|
import { KdfType } from '../enums/kdfType';
|
|
import { StorageLocation } from '../enums/storageLocation';
|
|
import { UriMatchType } from '../enums/uriMatchType';
|
|
|
|
import { CipherView } from '../models/view/cipherView';
|
|
import { CollectionView } from '../models/view/collectionView';
|
|
import { FolderView } from '../models/view/folderView';
|
|
import { SendView } from '../models/view/sendView';
|
|
|
|
import { EncString } from '../models/domain/encString';
|
|
import { GeneratedPasswordHistory } from '../models/domain/generatedPasswordHistory';
|
|
import { GlobalState } from '../models/domain/globalState';
|
|
import { Policy } from '../models/domain/policy';
|
|
import { State } from '../models/domain/state';
|
|
import { StorageOptions } from '../models/domain/storageOptions';
|
|
import { SymmetricCryptoKey } from '../models/domain/symmetricCryptoKey';
|
|
|
|
import { CipherData } from '../models/data/cipherData';
|
|
import { CollectionData } from '../models/data/collectionData';
|
|
import { EventData } from '../models/data/eventData';
|
|
import { FolderData } from '../models/data/folderData';
|
|
import { OrganizationData } from '../models/data/organizationData';
|
|
import { PolicyData } from '../models/data/policyData';
|
|
import { ProviderData } from '../models/data/providerData';
|
|
import { SendData } from '../models/data/sendData';
|
|
|
|
import { BehaviorSubject } from 'rxjs';
|
|
|
|
export class StateService implements StateServiceAbstraction {
|
|
accounts = new BehaviorSubject<{ [userId: string]: Account }>({});
|
|
private state: State = new State();
|
|
|
|
constructor(private storageService: StorageService, private secureStorageService: StorageService,
|
|
private logService: LogService) {
|
|
}
|
|
|
|
async init(): Promise<void> {
|
|
if (this.state.activeUserId == null) {
|
|
await this.loadStateFromDisk();
|
|
}
|
|
}
|
|
|
|
async loadStateFromDisk() {
|
|
if (await this.getActiveUserIdFromStorage() != null) {
|
|
const diskState = await this.storageService.get<State>('state', await this.defaultOnDiskOptions());
|
|
this.state = diskState;
|
|
await this.storageService.save('state', diskState, await this.defaultOnDiskMemoryOptions());
|
|
}
|
|
}
|
|
|
|
async addAccount(account: Account) {
|
|
this.state.accounts[account.profile.userId] = account;
|
|
await this.scaffoldNewAccountStorage(account);
|
|
await this.setActiveUser(account.profile.userId);
|
|
}
|
|
|
|
async setActiveUser(userId: string): Promise<void> {
|
|
this.state.activeUserId = userId;
|
|
const storedState = await this.storageService.get<State>('state', await this.defaultOnDiskOptions());
|
|
storedState.activeUserId = userId;
|
|
await this.storageService.save('state', storedState, await this.defaultOnDiskOptions());
|
|
await this.pushAccounts();
|
|
}
|
|
|
|
async clean(options?: StorageOptions): Promise<void> {
|
|
await this.removeAccountFromSessionStorage(options?.userId);
|
|
await this.removeAccountFromLocalStorage(options?.userId);
|
|
await this.removeAccountFromSecureStorage(options?.userId);
|
|
this.removeAccountFromMemory(options?.userId);
|
|
await this.pushAccounts();
|
|
}
|
|
|
|
async getAccessToken(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.tokens?.accessToken;
|
|
}
|
|
|
|
async setAccessToken(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.tokens.accessToken = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getAddEditCipherInfo(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.addEditCipherInfo;
|
|
}
|
|
|
|
async setAddEditCipherInfo(value: any, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.addEditCipherInfo = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getAlwaysShowDock(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.alwaysShowDock ?? false;
|
|
}
|
|
|
|
async setAlwaysShowDock(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.alwaysShowDock = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getApiKeyClientId(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile?.apiKeyClientId;
|
|
}
|
|
|
|
async setApiKeyClientId(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.profile.apiKeyClientId = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getApiKeyClientSecret(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile?.apiKeyClientSecret;
|
|
}
|
|
|
|
async setApiKeyClientSecret(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.profile.apiKeyClientId = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getAutoConfirmFingerPrints(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.autoConfirmFingerPrints ?? true;
|
|
}
|
|
|
|
async setAutoConfirmFingerprints(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.autoConfirmFingerPrints = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getAutoFillOnPageLoadDefault(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.autoFillOnPageLoadDefault ?? false;
|
|
}
|
|
|
|
async setAutoFillOnPageLoadDefault(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.autoFillOnPageLoadDefault = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getBiometricAwaitingAcceptance(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.biometricAwaitingAcceptance ?? false;
|
|
}
|
|
|
|
async setBiometricAwaitingAcceptance(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.biometricAwaitingAcceptance = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getBiometricFingerprintValidated(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.biometricFingerprintValidated ?? false;
|
|
}
|
|
|
|
async setBiometricFingerprintValidated(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.biometricFingerprintValidated = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getBiometricLocked(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.biometricLocked ?? false;
|
|
}
|
|
|
|
async setBiometricLocked(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.biometricLocked = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getBiometricText(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.biometricText;
|
|
}
|
|
|
|
async setBiometricText(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.biometricText = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getBiometricUnlock(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.biometricUnlock ?? false;
|
|
}
|
|
|
|
async setBiometricUnlock(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.biometricUnlock = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getCanAccessPremium(options?: StorageOptions): Promise<boolean> {
|
|
if (!await this.getIsAuthenticated(options)) {
|
|
return false;
|
|
}
|
|
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
if (account.profile.hasPremiumPersonally) {
|
|
return true;
|
|
}
|
|
|
|
const organizations = await this.getOrganizations(options);
|
|
if (organizations == null) {
|
|
return false;
|
|
}
|
|
|
|
for (const id of Object.keys(organizations)) {
|
|
const o = organizations[id];
|
|
if (o.enabled && o.usersGetPremium && !o.isProviderUser) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
async getClearClipboard(options?: StorageOptions): Promise<number> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.clearClipboard;
|
|
}
|
|
|
|
async setClearClipboard(value: number, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.clearClipboard = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getCollapsedGroupings(options?: StorageOptions): Promise<Set<string>> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.collapsedGroupings;
|
|
}
|
|
|
|
async setCollapsedGroupings(value: Set<string>, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.collapsedGroupings = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getConvertAccountToKeyConnector(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile?.convertAccountToKeyConnector;
|
|
}
|
|
|
|
async setConvertAccountToKeyConnector(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.profile.convertAccountToKeyConnector = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getCryptoMasterKey(options?: StorageOptions): Promise<SymmetricCryptoKey> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.keys?.cryptoMasterKey;
|
|
}
|
|
|
|
async setCryptoMasterKey(value: SymmetricCryptoKey, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.keys.cryptoMasterKey = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getCryptoMasterKeyAuto(options?: StorageOptions): Promise<SymmetricCryptoKey> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultSecureStorageOptions())))?.keys?.cryptoMasterKeyAuto;
|
|
}
|
|
|
|
async setCryptoMasterKeyAuto(value: SymmetricCryptoKey, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultSecureStorageOptions()));
|
|
account.keys.cryptoMasterKeyAuto = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultSecureStorageOptions()));
|
|
}
|
|
|
|
async getCryptoMasterKeyB64(options: StorageOptions): Promise<string> {
|
|
const value = (await this.getAccount(this.reconcileOptions(options, await this.defaultSecureStorageOptions())))?.keys?.cryptoMasterKeyB64;
|
|
return value;
|
|
}
|
|
|
|
async setCryptoMasterKeyB64(value: string, options: StorageOptions): Promise<void> {
|
|
try {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultSecureStorageOptions()));
|
|
if (account != null) {
|
|
account.keys.cryptoMasterKeyB64 = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultSecureStorageOptions()));
|
|
}
|
|
} catch (e) {
|
|
this.logService.error(e);
|
|
}
|
|
}
|
|
|
|
async getCryptoMasterKeyBiometric(options?: StorageOptions): Promise<SymmetricCryptoKey> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultSecureStorageOptions())))?.keys?.cryptoMasterKeyBiometric;
|
|
}
|
|
|
|
async setCryptoMasterKeyBiometric(value: SymmetricCryptoKey, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultSecureStorageOptions()));
|
|
account.keys.cryptoMasterKeyBiometric = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultSecureStorageOptions()));
|
|
}
|
|
|
|
async getDecodedToken(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.tokens?.decodedToken;
|
|
}
|
|
|
|
async setDecodedToken(value: any, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.tokens.decodedToken = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedCiphers(options?: StorageOptions): Promise<CipherView[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.ciphers?.decrypted;
|
|
}
|
|
|
|
async setDecryptedCiphers(value: CipherView[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.ciphers.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedCollections(options?: StorageOptions): Promise<CollectionView[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.collections?.decrypted;
|
|
}
|
|
|
|
async setDecryptedCollections(value: CollectionView[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.collections.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedCryptoSymmetricKey(options?: StorageOptions): Promise<SymmetricCryptoKey> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.keys?.cryptoSymmetricKey?.decrypted;
|
|
}
|
|
|
|
async setDecryptedCryptoSymmetricKey(value: SymmetricCryptoKey, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.keys.cryptoSymmetricKey.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedFolders(options?: StorageOptions): Promise<FolderView[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.folders?.decrypted;
|
|
}
|
|
|
|
async setDecryptedFolders(value: FolderView[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.folders.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedOrganizationKeys(options?: StorageOptions): Promise<Map<string, SymmetricCryptoKey>> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.keys?.organizationKeys?.decrypted;
|
|
}
|
|
|
|
async setDecryptedOrganizationKeys(value: Map<string, SymmetricCryptoKey>, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.keys.organizationKeys.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedPasswordGenerationHistory(options?: StorageOptions): Promise<GeneratedPasswordHistory[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.passwordGenerationHistory?.decrypted;
|
|
}
|
|
|
|
async setDecryptedPasswordGenerationHistory(value: GeneratedPasswordHistory[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.passwordGenerationHistory.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedPinProtected(options?: StorageOptions): Promise<EncString> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.pinProtected?.decrypted;
|
|
}
|
|
|
|
async setDecryptedPinProtected(value: EncString, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.pinProtected.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedPolicies(options?: StorageOptions): Promise<Policy[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.policies?.decrypted;
|
|
}
|
|
|
|
async setDecryptedPolicies(value: Policy[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.policies.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedPrivateKey(options?: StorageOptions): Promise<ArrayBuffer> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.keys?.privateKey?.decrypted;
|
|
}
|
|
|
|
async setDecryptedPrivateKey(value: ArrayBuffer, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.keys.privateKey.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedProviderKeys(options?: StorageOptions): Promise<Map<string, SymmetricCryptoKey>> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.keys?.providerKeys?.decrypted;
|
|
}
|
|
|
|
async setDecryptedProviderKeys(value: Map<string, SymmetricCryptoKey>, options?: StorageOptions): Promise<void> {
|
|
const account = (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)));
|
|
account.keys.providerKeys.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDecryptedSends(options?: StorageOptions): Promise<SendView[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.sends?.decrypted;
|
|
}
|
|
|
|
async setDecryptedSends(value: SendView[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.sends.decrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDefaultUriMatch(options?: StorageOptions): Promise<UriMatchType> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.defaultUriMatch;
|
|
}
|
|
|
|
async setDefaultUriMatch(value: UriMatchType, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.defaultUriMatch = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableAddLoginNotification(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableAddLoginNotification ?? false;
|
|
}
|
|
|
|
async setDisableAddLoginNotification(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableAddLoginNotification = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableAutoBiometricsPrompt(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableAutoBiometricsPrompt ?? false;
|
|
}
|
|
|
|
async setDisableAutoBiometricsPrompt(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableAutoBiometricsPrompt = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableAutoTotpCopy(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableAutoTotpCopy ?? false;
|
|
}
|
|
|
|
async setDisableAutoTotpCopy(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableAutoTotpCopy = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableBadgeCounter(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableBadgeCounter ?? false;
|
|
}
|
|
|
|
async setDisableBadgeCounter(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableBadgeCounter = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableChangedPasswordNotification(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableChangedPasswordNotification ?? false;
|
|
}
|
|
|
|
async setDisableChangedPasswordNotification(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableChangedPasswordNotification = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableContextMenuItem(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableContextMenuItem ?? false;
|
|
}
|
|
|
|
async setDisableContextMenuItem(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableContextMenuItem = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDisableFavicon(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.disableFavicon ?? false;
|
|
}
|
|
|
|
async setDisableFavicon(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
globals.disableFavicon = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getDisableGa(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.disableGa ?? false;
|
|
}
|
|
|
|
async setDisableGa(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.disableGa = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDontShowCardsCurrentTab(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.dontShowCardsCurrentTab ?? false;
|
|
}
|
|
|
|
async setDontShowCardsCurrentTab(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.dontShowCardsCurrentTab = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getDontShowIdentitiesCurrentTab(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.dontShowIdentitiesCurrentTab ?? false;
|
|
}
|
|
|
|
async setDontShowIdentitiesCurrentTab(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.dontShowIdentitiesCurrentTab = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEmail(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile?.email;
|
|
}
|
|
async setEmail(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.profile.email = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEmailVerified(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile.emailVerified ?? false;
|
|
}
|
|
async setEmailVerified(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.profile.emailVerified = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEnableAlwaysOnTop(options?: StorageOptions): Promise<boolean> {
|
|
const accountPreference = (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.enableAlwaysOnTop;
|
|
const globalPreference = (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.enableAlwaysOnTop;
|
|
return accountPreference ?? globalPreference ?? false;
|
|
}
|
|
async setEnableAlwaysOnTop(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.enableAlwaysOnTop = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.enableAlwaysOnTop = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEnableAutoFillOnPageLoad(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.enableAutoFillOnPageLoad ?? false;
|
|
}
|
|
async setEnableAutoFillOnPageLoad(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.enableAutoFillOnPageLoad = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEnableBiometric(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.enableBiometrics ?? false;
|
|
}
|
|
async setEnableBiometric(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.enableBiometrics = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEnableBrowserIntegration(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.enableBrowserIntegration ?? false;
|
|
}
|
|
async setEnableBrowserIntegration(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.enableBrowserIntegration = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEnableBrowserIntegrationFingerprint(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.enableBrowserIntegrationFingerprint ?? false;
|
|
}
|
|
async setEnableBrowserIntegrationFingerprint(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.enableBrowserIntegrationFingerprint = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEnableCloseToTray(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.enableCloseToTray ?? false;
|
|
}
|
|
async setEnableCloseToTray(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.enableCloseToTray = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEnableFullWidth(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.settings?.enableFullWidth ?? false;
|
|
}
|
|
async setEnableFullWidth(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
account.settings.enableFullWidth = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getEnableGravitars(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.settings?.enableGravitars ?? true;
|
|
}
|
|
async setEnableGravitars(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
account.settings.enableGravitars = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getEnableMinimizeToTray(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.enableMinimizeToTray ?? false;
|
|
}
|
|
async setEnableMinimizeToTray(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.enableMinimizeToTray = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEnableStartToTray(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings.enableStartToTray ?? false;
|
|
}
|
|
async setEnableStartToTray(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.enableStartToTray = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEnableTray(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.enableTray ?? false;
|
|
}
|
|
async setEnableTray(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.enableTray = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEncryptedCiphers(options?: StorageOptions): Promise<{ [id: string]: CipherData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())))?.data?.ciphers?.encrypted;
|
|
}
|
|
async setEncryptedCiphers(value: { [id: string]: CipherData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
account.data.ciphers.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
}
|
|
|
|
async getEncryptedCollections(options?: StorageOptions): Promise<{ [id: string]: CollectionData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())))?.data?.collections?.encrypted;
|
|
}
|
|
async setEncryptedCollections(value: { [id: string]: CollectionData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
account.data.collections.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
}
|
|
|
|
async getEncryptedCryptoSymmetricKey(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.keys.cryptoSymmetricKey.encrypted;
|
|
}
|
|
async setEncryptedCryptoSymmetricKey(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.keys.cryptoSymmetricKey.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedFolders(options?: StorageOptions): Promise<{ [id: string]: FolderData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())))?.data?.folders?.encrypted;
|
|
}
|
|
async setEncryptedFolders(value: { [id: string]: FolderData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
account.data.folders.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
}
|
|
|
|
async getEncryptedOrganizationKeys(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.keys?.organizationKeys.encrypted;
|
|
}
|
|
async setEncryptedOrganizationKeys(value: Map<string, SymmetricCryptoKey>, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.keys.organizationKeys.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedPasswordGenerationHistory(options?: StorageOptions): Promise<GeneratedPasswordHistory[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.data?.passwordGenerationHistory?.encrypted;
|
|
}
|
|
async setEncryptedPasswordGenerationHistory(value: GeneratedPasswordHistory[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.data.passwordGenerationHistory.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedPinProtected(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.pinProtected?.encrypted;
|
|
}
|
|
async setEncryptedPinProtected(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.pinProtected.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedPolicies(options?: StorageOptions): Promise<{ [id: string]: PolicyData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.data?.policies?.encrypted;
|
|
}
|
|
async setEncryptedPolicies(value: { [id: string]: PolicyData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.data.policies.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedPrivateKey(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.keys?.privateKey?.encrypted;
|
|
}
|
|
async setEncryptedPrivateKey(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.keys.privateKey.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedProviderKeys(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.keys?.providerKeys?.encrypted;
|
|
}
|
|
async setEncryptedProviderKeys(value: any, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.keys.providerKeys.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEncryptedSends(options?: StorageOptions): Promise<{ [id: string]: SendData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())))?.data?.sends.encrypted;
|
|
}
|
|
async setEncryptedSends(value: { [id: string]: SendData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
account.data.sends.encrypted = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
}
|
|
|
|
async getEntityId(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.entityId;
|
|
}
|
|
async setEntityId(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.entityId = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEntityType(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.entityType;
|
|
}
|
|
async setEntityType(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.entityType = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEnvironmentUrls(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.environmentUrls;
|
|
}
|
|
async setEnvironmentUrls(value: any, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.environmentUrls = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEquivalentDomains(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.equivalentDomains;
|
|
}
|
|
async setEquivalentDomains(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.equivalentDomains = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getEventCollection(options?: StorageOptions): Promise<EventData[]> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.data?.eventCollection;
|
|
}
|
|
async setEventCollection(value: EventData[], options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.data.eventCollection = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getEverBeenUnlocked(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.everBeenUnlocked ?? false;
|
|
}
|
|
|
|
async setEverBeenUnlocked(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.everBeenUnlocked = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getForcePasswordReset(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.forcePasswordReset ?? false;
|
|
}
|
|
async setForcePasswordReset(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.forcePasswordReset = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getInstalledVersion(options?: StorageOptions): Promise<string> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.installedVersion;
|
|
}
|
|
async setInstalledVersion(value: string, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.installedVersion = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getIsAuthenticated(options?: StorageOptions): Promise<boolean> {
|
|
return await this.getAccessToken(options) != null && await this.getUserId(options) != null;
|
|
}
|
|
|
|
async getKdfIterations(options?: StorageOptions): Promise<number> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.data?.kdfIterations;
|
|
}
|
|
async setKdfIterations(value: number, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.data.kdfIterations = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getKdfType(options?: StorageOptions): Promise<KdfType> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.data?.kdfType;
|
|
}
|
|
async setKdfType(value: KdfType, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.data.kdfType = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getKeyHash(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.keys?.keyHash;
|
|
}
|
|
|
|
async setKeyHash(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.keys.keyHash = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getLastActive(options?: StorageOptions): Promise<number> {
|
|
const lastActive = (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile?.lastActive;
|
|
return lastActive ?? (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.lastActive;
|
|
}
|
|
async setLastActive(value: number, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
if (account != null) {
|
|
account.profile.lastActive = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.lastActive = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getLastSync(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())))?.profile?.lastSync;
|
|
}
|
|
async setLastSync(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
account.profile.lastSync = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
}
|
|
|
|
async getLegacyEtmKey(options?: StorageOptions): Promise<SymmetricCryptoKey> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.keys?.legacyEtmKey;
|
|
}
|
|
async setLegacyEtmKey(value: SymmetricCryptoKey, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.keys.legacyEtmKey = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getLocalData(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.localData;
|
|
}
|
|
async setLocalData(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.localData = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getLocale(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.settings?.locale;
|
|
}
|
|
async setLocale(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
account.settings.locale = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getLoginRedirect(options?: StorageOptions): Promise<any> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.loginRedirect;
|
|
}
|
|
async setLoginRedirect(value: any, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
globals.loginRedirect = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getMainWindowSize(options?: StorageOptions): Promise<number> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.mainWindowSize;
|
|
}
|
|
async setMainWindowSize(value: number, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
globals.mainWindowSize = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getMinimizeOnCopyToClipboard(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.minimizeOnCopyToClipboard ?? false;
|
|
}
|
|
async setMinimizeOnCopyToClipboard(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.minimizeOnCopyToClipboard = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getNeverDomains(options?: StorageOptions): Promise<{ [id: string]: any; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.neverDomains;
|
|
}
|
|
async setNeverDomains(value: { [id: string]: any; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.neverDomains = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getNoAutoPromptBiometrics(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.noAutoPromptBiometrics ?? false;
|
|
}
|
|
async setNoAutoPromptBiometrics(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.noAutoPromptBiometrics = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getNoAutoPromptBiometricsText(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.settings?.noAutoPromptBiometricsText;
|
|
}
|
|
async setNoAutoPromptBiometricsText(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.noAutoPromptBiometricsText = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getOpenAtLogin(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.openAtLogin ?? false;
|
|
}
|
|
async setOpenAtLogin(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.openAtLogin = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getOrganizationInvitation(options?: StorageOptions): Promise<any> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.organizationInvitation;
|
|
}
|
|
async setOrganizationInvitation(value: any, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
globals.organizationInvitation = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getOrganizations(options?: StorageOptions): Promise<{ [id: string]: OrganizationData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.organizations;
|
|
}
|
|
async setOrganizations(value: { [id: string]: OrganizationData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.organizations = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getPasswordGenerationOptions(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.passwordGenerationOptions;
|
|
}
|
|
async setPasswordGenerationOptions(value: any, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.settings.passwordGenerationOptions = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getProtectedPin(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.settings?.protectedPin;
|
|
}
|
|
async setProtectedPin(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.settings.protectedPin = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getProviders(options?: StorageOptions): Promise<{ [id: string]: ProviderData; }> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.data?.providers;
|
|
}
|
|
async setProviders(value: { [id: string]: ProviderData; }, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.data.providers = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getPublicKey(options?: StorageOptions): Promise<ArrayBuffer> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.keys?.publicKey;
|
|
}
|
|
async setPublicKey(value: ArrayBuffer, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.keys.publicKey = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getRefreshToken(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.tokens?.refreshToken;
|
|
}
|
|
async setRefreshToken(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
account.tokens.refreshToken = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
async getRememberedEmail(options?: StorageOptions): Promise<string> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.rememberedEmail;
|
|
}
|
|
async setRememberedEmail(value: string, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
globals.rememberedEmail = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getSecurityStamp(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.tokens?.securityStamp;
|
|
}
|
|
async setSecurityStamp(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.tokens.securityStamp = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getSettings(options?: StorageOptions): Promise<any> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())))?.settings?.settings;
|
|
}
|
|
async setSettings(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
account.settings.settings = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()));
|
|
}
|
|
|
|
async getSsoCodeVerifier(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.ssoCodeVerifier;
|
|
}
|
|
async setSsoCodeVerifier(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.ssoCodeVerifier = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getSsoOrgIdentifier(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.profile?.ssoOrganizationIdentifier;
|
|
}
|
|
async setSsoOrganizationIdentifier(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
account.profile.ssoOrganizationIdentifier = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getSsoState(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.ssoState;
|
|
}
|
|
async setSsoState(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.ssoState = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getTheme(options?: StorageOptions): Promise<string> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.theme;
|
|
}
|
|
|
|
async setTheme(value: string, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
globals.theme = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getTwoFactorToken(options?: StorageOptions): Promise<string> {
|
|
return (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.twoFactorToken;
|
|
}
|
|
async setTwoFactorToken(value: string, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
globals.twoFactorToken = value;
|
|
await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getUserId(options?: StorageOptions): Promise<string> {
|
|
return (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))?.profile?.userId;
|
|
}
|
|
|
|
async getUsesKeyConnector(options?: StorageOptions): Promise<boolean> {
|
|
return (await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions)))?.profile?.usesKeyConnector;
|
|
}
|
|
|
|
async setUsesKeyConnector(value: boolean, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
account.profile.usesKeyConnector = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, this.defaultInMemoryOptions));
|
|
}
|
|
|
|
async getVaultTimeout(options?: StorageOptions): Promise<number> {
|
|
const accountVaultTimeout = (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.settings?.vaultTimeout;
|
|
const globalVaultTimeout = (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.vaultTimeout;
|
|
return accountVaultTimeout ?? globalVaultTimeout;
|
|
}
|
|
async setVaultTimeout(value: number, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
account.settings.vaultTimeout = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getVaultTimeoutAction(options?: StorageOptions): Promise<string> {
|
|
const accountVaultTimeoutAction = (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.settings?.vaultTimeoutAction;
|
|
const globalVaultTimeoutAction = (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions())))?.vaultTimeoutAction;
|
|
return accountVaultTimeoutAction ?? globalVaultTimeoutAction;
|
|
}
|
|
async setVaultTimeoutAction(value: string, options?: StorageOptions): Promise<void> {
|
|
const account = await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
account.settings.vaultTimeoutAction = value;
|
|
await this.saveAccount(account, this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()));
|
|
}
|
|
|
|
async getWindow(): Promise<Map<string, any>> {
|
|
const globals = await this.getGlobals(await this.defaultOnDiskOptions());
|
|
return globals?.window != null && Object.keys(globals.window).length > 0 ?
|
|
globals.window :
|
|
new Map<string, any>();
|
|
}
|
|
|
|
async setWindow(value: Map<string, any>, options?: StorageOptions): Promise<void> {
|
|
const globals = await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
globals.window = value;
|
|
return await this.saveGlobals(globals, this.reconcileOptions(options, await this.defaultOnDiskOptions()));
|
|
}
|
|
|
|
private async getGlobals(options: StorageOptions): Promise<GlobalState> {
|
|
let globals: GlobalState;
|
|
if (this.useMemory(options.storageLocation)) {
|
|
globals = this.getGlobalsFromMemory();
|
|
}
|
|
|
|
if (this.useDisk && globals == null) {
|
|
globals = await this.getGlobalsFromDisk(options);
|
|
}
|
|
|
|
return globals ?? new GlobalState();
|
|
}
|
|
|
|
private async saveGlobals(globals: GlobalState, options: StorageOptions) {
|
|
return this.useMemory(options.storageLocation) ?
|
|
this.saveGlobalsToMemory(globals) :
|
|
await this.saveGlobalsToDisk(globals, options);
|
|
}
|
|
|
|
private getGlobalsFromMemory(): GlobalState {
|
|
return this.state.globals;
|
|
}
|
|
|
|
private async getGlobalsFromDisk(options: StorageOptions): Promise<GlobalState> {
|
|
return (await this.storageService.get<State>('state', options))?.globals;
|
|
}
|
|
|
|
private saveGlobalsToMemory(globals: GlobalState): void {
|
|
this.state.globals = globals;
|
|
}
|
|
|
|
private async saveGlobalsToDisk(globals: GlobalState, options: StorageOptions): Promise<void> {
|
|
if (options.useSecureStorage) {
|
|
const state = await this.secureStorageService.get<State>('state', options) ?? new State();
|
|
state.globals = globals;
|
|
await this.secureStorageService.save('state', state, options);
|
|
} else {
|
|
const state = await this.storageService.get<State>('state', options) ?? new State();
|
|
state.globals = globals;
|
|
await this.storageService.save('state', state, options);
|
|
}
|
|
}
|
|
|
|
private async getAccount(options: StorageOptions): Promise<Account> {
|
|
try {
|
|
let account: Account;
|
|
if (this.useMemory(options.storageLocation)) {
|
|
account = this.getAccountFromMemory(options);
|
|
}
|
|
|
|
if (this.useDisk(options.storageLocation) && account == null) {
|
|
account = await this.getAccountFromDisk(options);
|
|
}
|
|
|
|
return new Account(account) ?? null;
|
|
}
|
|
catch (e) {
|
|
this.logService.error(e);
|
|
}
|
|
}
|
|
|
|
private getAccountFromMemory(options: StorageOptions): Account {
|
|
if (this.state.accounts == null) {
|
|
return null;
|
|
}
|
|
return this.state.accounts[this.getUserIdFromMemory(options)];
|
|
}
|
|
|
|
private getUserIdFromMemory(options: StorageOptions): string {
|
|
return options?.userId != null ?
|
|
this.state.accounts[options.userId]?.profile?.userId :
|
|
this.state.activeUserId;
|
|
}
|
|
|
|
private async getAccountFromDisk(options: StorageOptions): Promise<Account> {
|
|
if (options?.userId == null && this.state.activeUserId == null) {
|
|
return null;
|
|
}
|
|
|
|
const state = options?.useSecureStorage ?
|
|
await this.secureStorageService.get<State>('state', options) ??
|
|
await this.storageService.get<State>('state', this.reconcileOptions(options, { htmlStorageLocation: HtmlStorageLocation.Local })) :
|
|
await this.storageService.get<State>('state', options);
|
|
|
|
return state?.accounts[options?.userId ?? this.state.activeUserId];
|
|
}
|
|
|
|
private useMemory(storageLocation: StorageLocation) {
|
|
return storageLocation === StorageLocation.Memory ||
|
|
storageLocation === StorageLocation.Both;
|
|
}
|
|
|
|
private useDisk(storageLocation: StorageLocation) {
|
|
return storageLocation === StorageLocation.Disk ||
|
|
storageLocation === StorageLocation.Both;
|
|
}
|
|
|
|
private async saveAccount(account: Account, options: StorageOptions = {
|
|
storageLocation: StorageLocation.Both,
|
|
useSecureStorage: false,
|
|
}) {
|
|
return this.useMemory(options.storageLocation) ?
|
|
await this.saveAccountToMemory(account) :
|
|
await this.saveAccountToDisk(account, options);
|
|
}
|
|
|
|
private async saveAccountToDisk(account: Account, options: StorageOptions): Promise<void> {
|
|
const storageLocation = options.useSecureStorage ?
|
|
this.secureStorageService :
|
|
this.storageService;
|
|
|
|
const state = await storageLocation.get<State>('state', options) ?? new State();
|
|
state.accounts[account.profile.userId] = account;
|
|
|
|
await storageLocation.save('state', state, options);
|
|
await this.pushAccounts();
|
|
}
|
|
|
|
private async saveAccountToMemory(account: Account): Promise<void> {
|
|
if (this.getAccountFromMemory({ userId: account.profile.userId }) !== null) {
|
|
this.state.accounts[account.profile.userId] = account;
|
|
}
|
|
await this.pushAccounts();
|
|
}
|
|
|
|
private async scaffoldNewAccountStorage(account: Account): Promise<void> {
|
|
const storedState = await this.storageService.get<State>('state', await this.defaultOnDiskOptions()) ?? new State();
|
|
const storedAccount = storedState.accounts[account.profile.userId];
|
|
if (storedAccount != null) {
|
|
storedAccount.tokens.accessToken = account.tokens.accessToken;
|
|
storedAccount.tokens.refreshToken = account.tokens.refreshToken;
|
|
account = storedAccount;
|
|
}
|
|
storedState.accounts[account.profile.userId] = account;
|
|
await this.storageService.save('state', storedState, await this.defaultOnDiskLocalOptions());
|
|
await this.storageService.save('state', storedState, await this.defaultOnDiskMemoryOptions());
|
|
await this.storageService.save('state', storedState, await this.defaultOnDiskOptions());
|
|
|
|
await this.scaffoldNewAccountSecureStorage(account);
|
|
}
|
|
|
|
private async scaffoldNewAccountSecureStorage(account: Account): Promise<void> {
|
|
const storedState = await this.secureStorageService.get<State>('state', await this.defaultSecureStorageOptions()) ?? new State();
|
|
storedState.accounts[account.profile.userId] = account;
|
|
await this.secureStorageService.save('state', storedState);
|
|
}
|
|
|
|
private async pushAccounts(): Promise<void> {
|
|
if (this.state?.accounts == null || Object.keys(this.state.accounts).length < 1) {
|
|
return;
|
|
}
|
|
|
|
for (const i in this.state.accounts) {
|
|
if (this.state.accounts[i].profile.userId === this.state.activeUserId) {
|
|
this.state.accounts[i].profile.authenticationStatus = AuthenticationStatus.Active;
|
|
} else {
|
|
const vaultTimeout = await this.getVaultTimeout({
|
|
storageLocation: StorageLocation.Disk,
|
|
userId: this.state.accounts[i].profile.userId,
|
|
});
|
|
const lastActive = await this.getLastActive({
|
|
storageLocation: StorageLocation.Disk,
|
|
userId: this.state.accounts[i].profile.userId,
|
|
});
|
|
const diffSeconds = ((new Date()).getTime() - lastActive) / 1000;
|
|
this.state.accounts[i].profile.authenticationStatus = diffSeconds < (vaultTimeout * 60) ?
|
|
AuthenticationStatus.Unlocked :
|
|
AuthenticationStatus.Locked;
|
|
}
|
|
}
|
|
this.accounts.next(this.state.accounts);
|
|
}
|
|
|
|
private reconcileOptions(requestedOptions: StorageOptions, defaultOptions: StorageOptions): StorageOptions {
|
|
if (requestedOptions == null) {
|
|
return defaultOptions;
|
|
}
|
|
requestedOptions.userId = requestedOptions?.userId ?? defaultOptions.userId;
|
|
requestedOptions.storageLocation = requestedOptions?.storageLocation ?? defaultOptions.storageLocation;
|
|
requestedOptions.useSecureStorage = requestedOptions?.useSecureStorage ?? defaultOptions.useSecureStorage;
|
|
requestedOptions.htmlStorageLocation = requestedOptions?.htmlStorageLocation ?? defaultOptions.htmlStorageLocation;
|
|
return requestedOptions;
|
|
}
|
|
|
|
private get defaultInMemoryOptions(): StorageOptions {
|
|
return { storageLocation: StorageLocation.Memory, userId: this.state.activeUserId };
|
|
}
|
|
|
|
private async defaultOnDiskOptions(): Promise<StorageOptions> {
|
|
return {
|
|
storageLocation: StorageLocation.Disk,
|
|
htmlStorageLocation: HtmlStorageLocation.Session,
|
|
userId: await this.storageService.get('activeUserId'),
|
|
useSecureStorage: false,
|
|
};
|
|
}
|
|
|
|
private async defaultOnDiskLocalOptions(): Promise<StorageOptions> {
|
|
return {
|
|
storageLocation: StorageLocation.Disk,
|
|
htmlStorageLocation: HtmlStorageLocation.Local,
|
|
userId: await this.storageService.get('activeUserId'),
|
|
useSecureStorage: false,
|
|
};
|
|
}
|
|
|
|
private async defaultOnDiskMemoryOptions(): Promise<StorageOptions> {
|
|
return {
|
|
storageLocation: StorageLocation.Disk,
|
|
htmlStorageLocation: HtmlStorageLocation.Memory,
|
|
userId: await this.storageService.get('activeUserId'),
|
|
useSecureStorage: false,
|
|
};
|
|
}
|
|
|
|
private async defaultSecureStorageOptions(): Promise<StorageOptions> {
|
|
return {
|
|
storageLocation: StorageLocation.Disk,
|
|
useSecureStorage: true,
|
|
userId: await this.storageService.get('activeUserId'),
|
|
};
|
|
}
|
|
|
|
private async getActiveUserIdFromStorage(): Promise<string> {
|
|
const state = await this.storageService.get<State>('state', await this.defaultOnDiskOptions());
|
|
return state?.activeUserId;
|
|
}
|
|
|
|
private async removeAccountFromLocalStorage(userId: string): Promise<void> {
|
|
const state = await this.secureStorageService.get<State>('state', { htmlStorageLocation: HtmlStorageLocation.Local });
|
|
if (state?.accounts[userId ?? this.state.activeUserId] == null) {
|
|
return;
|
|
}
|
|
|
|
delete state.accounts[userId ?? this.state.activeUserId];
|
|
await this.storageService.save('state', state, { htmlStorageLocation: HtmlStorageLocation.Local });
|
|
}
|
|
|
|
private async removeAccountFromSessionStorage(userId: string): Promise<void> {
|
|
const state = await this.secureStorageService.get<State>('state', { htmlStorageLocation: HtmlStorageLocation.Session });
|
|
const account = state?.accounts[userId ?? this.state.activeUserId];
|
|
if (account == null) {
|
|
return;
|
|
}
|
|
|
|
delete state.accounts[userId ?? this.state.activeUserId];
|
|
await this.storageService.save('state', state, { htmlStorageLocation: HtmlStorageLocation.Session });
|
|
}
|
|
|
|
private async removeAccountFromSecureStorage(userId: string): Promise<void> {
|
|
const state = await this.secureStorageService.get<State>('state');
|
|
if (state?.accounts[userId ?? this.state.activeUserId] == null) {
|
|
return;
|
|
}
|
|
delete state.accounts[userId ?? this.state.activeUserId];
|
|
await this.secureStorageService.save('state', state);
|
|
}
|
|
|
|
private removeAccountFromMemory(userId: string): void {
|
|
if (this.state?.accounts[userId ?? this.state.activeUserId] == null) {
|
|
return;
|
|
}
|
|
delete this.state.accounts[userId ?? this.state.activeUserId];
|
|
}
|
|
}
|