[SG-998] and [SG-999] Vault and Autofill team refactor (#4542)

* Move DeprecatedVaultFilterService to vault folder

* [libs] move VaultItemsComponent

* [libs] move AddEditComponent

* [libs] move AddEditCustomFields

* [libs] move attachmentsComponent

* [libs] folderAddEditComponent

* [libs] IconComponent

* [libs] PasswordRepormptComponent

* [libs] PremiumComponent

* [libs] ViewCustomFieldsComponent

* [libs] ViewComponent

* [libs] PasswordRepromptService

* [libs] Move FolderService and FolderApiService abstractions

* [libs] FolderService imports

* [libs] PasswordHistoryComponent

* [libs] move Sync and SyncNotifier abstractions

* [libs] SyncService imports

* [libs] fix file casing for passwordReprompt abstraction

* [libs] SyncNotifier import fix

* [libs] CipherServiceAbstraction

* [libs] PasswordRepromptService abstraction

* [libs] Fix file casing for angular passwordReprompt service

* [libs] fix file casing for SyncNotifierService

* [libs] CipherRepromptType

* [libs] rename CipherRepromptType

* [libs] CipherType

* [libs] Rename CipherType

* [libs] CipherData

* [libs] FolderData

* [libs] PasswordHistoryData

* [libs] AttachmentData

* [libs] CardData

* [libs] FieldData

* [libs] IdentityData

* [libs] LocalData

* [libs] LoginData

* [libs] SecureNoteData

* [libs] LoginUriData

* [libs] Domain classes

* [libs] SecureNote

* [libs] Request models

* [libs] Response models

* [libs] View part 1

* [libs] Views part 2

* [libs] Move folder services

* [libs] Views fixes

* [libs] Move sync services

* [libs] cipher service

* [libs] Types

* [libs] Sync file casing

* [libs] Fix folder service import

* [libs] Move spec files

* [libs] casing fixes on spec files

* [browser] Autofill background, clipboard, commands

* [browser] Fix ContextMenusBackground casing

* [browser] Rename fix

* [browser] Autofill content

* [browser] autofill.js

* [libs] enpass importer spec fix

* [browser] autofill models

* [browser] autofill manifest path updates

* [browser] Autofill notification files

* [browser] autofill services

* [browser] Fix file casing

* [browser] Vault popup loose components

* [browser] Vault components

* [browser] Manifest fixes

* [browser] Vault services

* [cli] vault commands and models

* [browser] File capitilization fixes

* [desktop] Vault components and services

* [web] vault loose components

* [web] Vault components

* [browser] Fix misc-utils import

* [libs] Fix psono spec imports

* [fix] Add comments to address lint rules

libs/common/src/vault/services/cipher.service.spec.ts

@@ -0,0 +1,74 @@
+// eslint-disable-next-line no-restricted-imports
+import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
+
+import { ApiService } from "../../abstractions/api.service";
+import { CryptoService } from "../../abstractions/crypto.service";
+import { EncryptService } from "../../abstractions/encrypt.service";
+import { FileUploadService } from "../../abstractions/fileUpload.service";
+import { I18nService } from "../../abstractions/i18n.service";
+import { LogService } from "../../abstractions/log.service";
+import { SearchService } from "../../abstractions/search.service";
+import { SettingsService } from "../../abstractions/settings.service";
+import { StateService } from "../../abstractions/state.service";
+import { EncArrayBuffer } from "../../models/domain/enc-array-buffer";
+import { EncString } from "../../models/domain/enc-string";
+import { SymmetricCryptoKey } from "../../models/domain/symmetric-crypto-key";
+import { Cipher } from "../models/domain/cipher";
+
+import { CipherService } from "./cipher.service";
+
+const ENCRYPTED_TEXT = "This data has been encrypted";
+const ENCRYPTED_BYTES = Substitute.for<EncArrayBuffer>();
+
+describe("Cipher Service", () => {
+  let cryptoService: SubstituteOf<CryptoService>;
+  let stateService: SubstituteOf<StateService>;
+  let settingsService: SubstituteOf<SettingsService>;
+  let apiService: SubstituteOf<ApiService>;
+  let fileUploadService: SubstituteOf<FileUploadService>;
+  let i18nService: SubstituteOf<I18nService>;
+  let searchService: SubstituteOf<SearchService>;
+  let logService: SubstituteOf<LogService>;
+  let encryptService: SubstituteOf<EncryptService>;
+
+  let cipherService: CipherService;
+
+  beforeEach(() => {
+    cryptoService = Substitute.for<CryptoService>();
+    stateService = Substitute.for<StateService>();
+    settingsService = Substitute.for<SettingsService>();
+    apiService = Substitute.for<ApiService>();
+    fileUploadService = Substitute.for<FileUploadService>();
+    i18nService = Substitute.for<I18nService>();
+    searchService = Substitute.for<SearchService>();
+    logService = Substitute.for<LogService>();
+    encryptService = Substitute.for<EncryptService>();
+
+    cryptoService.encryptToBytes(Arg.any(), Arg.any()).resolves(ENCRYPTED_BYTES);
+    cryptoService.encrypt(Arg.any(), Arg.any()).resolves(new EncString(ENCRYPTED_TEXT));
+
+    cipherService = new CipherService(
+      cryptoService,
+      settingsService,
+      apiService,
+      fileUploadService,
+      i18nService,
+      () => searchService,
+      logService,
+      stateService,
+      encryptService
+    );
+  });
+
+  it("attachments upload encrypted file contents", async () => {
+    const fileName = "filename";
+    const fileData = new Uint8Array(10).buffer;
+    cryptoService.getOrgKey(Arg.any()).resolves(new SymmetricCryptoKey(new Uint8Array(32).buffer));
+
+    await cipherService.saveAttachmentRawWithServer(new Cipher(), fileName, fileData);
+
+    fileUploadService
+      .received(1)
+      .uploadCipherAttachment(Arg.any(), Arg.any(), new EncString(ENCRYPTED_TEXT), ENCRYPTED_BYTES);
+  });
+});

libs/common/src/vault/services/folder/folder-api.service.ts

@@ -0,0 +1,50 @@
+import { ApiService } from "../../../abstractions/api.service";
+import { FolderApiServiceAbstraction } from "../../../vault/abstractions/folder/folder-api.service.abstraction";
+import { InternalFolderService } from "../../../vault/abstractions/folder/folder.service.abstraction";
+import { FolderData } from "../../../vault/models/data/folder.data";
+import { Folder } from "../../../vault/models/domain/folder";
+import { FolderRequest } from "../../../vault/models/request/folder.request";
+import { FolderResponse } from "../../../vault/models/response/folder.response";
+
+export class FolderApiService implements FolderApiServiceAbstraction {
+  constructor(private folderService: InternalFolderService, private apiService: ApiService) {}
+
+  async save(folder: Folder): Promise<any> {
+    const request = new FolderRequest(folder);
+
+    let response: FolderResponse;
+    if (folder.id == null) {
+      response = await this.postFolder(request);
+      folder.id = response.id;
+    } else {
+      response = await this.putFolder(folder.id, request);
+    }
+
+    const data = new FolderData(response);
+    await this.folderService.upsert(data);
+  }
+
+  async delete(id: string): Promise<any> {
+    await this.deleteFolder(id);
+    await this.folderService.delete(id);
+  }
+
+  async get(id: string): Promise<FolderResponse> {
+    const r = await this.apiService.send("GET", "/folders/" + id, null, true, true);
+    return new FolderResponse(r);
+  }
+
+  private async postFolder(request: FolderRequest): Promise<FolderResponse> {
+    const r = await this.apiService.send("POST", "/folders", request, true, true);
+    return new FolderResponse(r);
+  }
+
+  async putFolder(id: string, request: FolderRequest): Promise<FolderResponse> {
+    const r = await this.apiService.send("PUT", "/folders/" + id, request, true, true);
+    return new FolderResponse(r);
+  }
+
+  private deleteFolder(id: string): Promise<any> {
+    return this.apiService.send("DELETE", "/folders/" + id, null, true, false);
+  }
+}

libs/common/src/vault/services/folder/folder.service.spec.ts

@@ -0,0 +1,202 @@
+// eslint-disable-next-line no-restricted-imports
+import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
+import { BehaviorSubject, firstValueFrom } from "rxjs";
+
+import { CryptoService } from "../../../abstractions/crypto.service";
+import { EncryptService } from "../../../abstractions/encrypt.service";
+import { I18nService } from "../../../abstractions/i18n.service";
+import { EncString } from "../../../models/domain/enc-string";
+import { ContainerService } from "../../../services/container.service";
+import { StateService } from "../../../services/state.service";
+import { CipherService } from "../../abstractions/cipher.service";
+import { FolderData } from "../../models/data/folder.data";
+import { FolderView } from "../../models/view/folder.view";
+import { FolderService } from "../../services/folder/folder.service";
+
+describe("Folder Service", () => {
+  let folderService: FolderService;
+
+  let cryptoService: SubstituteOf<CryptoService>;
+  let encryptService: SubstituteOf<EncryptService>;
+  let i18nService: SubstituteOf<I18nService>;
+  let cipherService: SubstituteOf<CipherService>;
+  let stateService: SubstituteOf<StateService>;
+  let activeAccount: BehaviorSubject<string>;
+  let activeAccountUnlocked: BehaviorSubject<boolean>;
+
+  beforeEach(() => {
+    cryptoService = Substitute.for();
+    encryptService = Substitute.for();
+    i18nService = Substitute.for();
+    cipherService = Substitute.for();
+    stateService = Substitute.for();
+    activeAccount = new BehaviorSubject("123");
+    activeAccountUnlocked = new BehaviorSubject(true);
+
+    stateService.getEncryptedFolders().resolves({
+      "1": folderData("1", "test"),
+    });
+    stateService.activeAccount$.returns(activeAccount);
+    stateService.activeAccountUnlocked$.returns(activeAccountUnlocked);
+    (window as any).bitwardenContainerService = new ContainerService(cryptoService, encryptService);
+
+    folderService = new FolderService(cryptoService, i18nService, cipherService, stateService);
+  });
+
+  it("encrypt", async () => {
+    const model = new FolderView();
+    model.id = "2";
+    model.name = "Test Folder";
+
+    cryptoService.encrypt(Arg.any()).resolves(new EncString("ENC"));
+    cryptoService.decryptToUtf8(Arg.any()).resolves("DEC");
+
+    const result = await folderService.encrypt(model);
+
+    expect(result).toEqual({
+      id: "2",
+      name: {
+        encryptedString: "ENC",
+        encryptionType: 0,
+      },
+    });
+  });
+
+  describe("get", () => {
+    it("exists", async () => {
+      const result = await folderService.get("1");
+
+      expect(result).toEqual({
+        id: "1",
+        name: {
+          decryptedValue: [],
+          encryptedString: "test",
+          encryptionType: 0,
+        },
+        revisionDate: null,
+      });
+    });
+
+    it("not exists", async () => {
+      const result = await folderService.get("2");
+
+      expect(result).toBe(undefined);
+    });
+  });
+
+  it("upsert", async () => {
+    await folderService.upsert(folderData("2", "test 2"));
+
+    expect(await firstValueFrom(folderService.folders$)).toEqual([
+      {
+        id: "1",
+        name: {
+          decryptedValue: [],
+          encryptedString: "test",
+          encryptionType: 0,
+        },
+        revisionDate: null,
+      },
+      {
+        id: "2",
+        name: {
+          decryptedValue: [],
+          encryptedString: "test 2",
+          encryptionType: 0,
+        },
+        revisionDate: null,
+      },
+    ]);
+
+    expect(await firstValueFrom(folderService.folderViews$)).toEqual([
+      { id: "1", name: [], revisionDate: null },
+      { id: "2", name: [], revisionDate: null },
+      { id: null, name: [], revisionDate: null },
+    ]);
+  });
+
+  it("replace", async () => {
+    await folderService.replace({ "2": folderData("2", "test 2") });
+
+    expect(await firstValueFrom(folderService.folders$)).toEqual([
+      {
+        id: "2",
+        name: {
+          decryptedValue: [],
+          encryptedString: "test 2",
+          encryptionType: 0,
+        },
+        revisionDate: null,
+      },
+    ]);
+
+    expect(await firstValueFrom(folderService.folderViews$)).toEqual([
+      { id: "2", name: [], revisionDate: null },
+      { id: null, name: [], revisionDate: null },
+    ]);
+  });
+
+  it("delete", async () => {
+    await folderService.delete("1");
+
+    expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
+
+    expect(await firstValueFrom(folderService.folderViews$)).toEqual([
+      { id: null, name: [], revisionDate: null },
+    ]);
+  });
+
+  it("clearCache", async () => {
+    await folderService.clearCache();
+
+    expect((await firstValueFrom(folderService.folders$)).length).toBe(1);
+    expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
+  });
+
+  it("locking should clear", async () => {
+    activeAccountUnlocked.next(false);
+    // Sleep for 100ms to avoid timing issues
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
+    expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
+  });
+
+  describe("clear", () => {
+    it("null userId", async () => {
+      await folderService.clear();
+
+      stateService.received(1).setEncryptedFolders(Arg.any(), Arg.any());
+
+      expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
+      expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
+    });
+
+    it("matching userId", async () => {
+      stateService.getUserId().resolves("1");
+      await folderService.clear("1");
+
+      stateService.received(1).setEncryptedFolders(Arg.any(), Arg.any());
+
+      expect((await firstValueFrom(folderService.folders$)).length).toBe(0);
+      expect((await firstValueFrom(folderService.folderViews$)).length).toBe(0);
+    });
+
+    it("missmatching userId", async () => {
+      await folderService.clear("12");
+
+      stateService.received(1).setEncryptedFolders(Arg.any(), Arg.any());
+
+      expect((await firstValueFrom(folderService.folders$)).length).toBe(1);
+      expect((await firstValueFrom(folderService.folderViews$)).length).toBe(2);
+    });
+  });
+
+  function folderData(id: string, name: string) {
+    const data = new FolderData({} as any);
+    data.id = id;
+    data.name = name;
+
+    return data;
+  }
+});

libs/common/src/vault/services/folder/folder.service.ts

@@ -0,0 +1,193 @@
+import { BehaviorSubject, concatMap } from "rxjs";
+
+import { CryptoService } from "../../../abstractions/crypto.service";
+import { I18nService } from "../../../abstractions/i18n.service";
+import { StateService } from "../../../abstractions/state.service";
+import { Utils } from "../../../misc/utils";
+import { SymmetricCryptoKey } from "../../../models/domain/symmetric-crypto-key";
+import { CipherService } from "../../../vault/abstractions/cipher.service";
+import { InternalFolderService as InternalFolderServiceAbstraction } from "../../../vault/abstractions/folder/folder.service.abstraction";
+import { CipherData } from "../../../vault/models/data/cipher.data";
+import { FolderData } from "../../../vault/models/data/folder.data";
+import { Folder } from "../../../vault/models/domain/folder";
+import { FolderView } from "../../../vault/models/view/folder.view";
+
+export class FolderService implements InternalFolderServiceAbstraction {
+  protected _folders: BehaviorSubject<Folder[]> = new BehaviorSubject([]);
+  protected _folderViews: BehaviorSubject<FolderView[]> = new BehaviorSubject([]);
+
+  folders$ = this._folders.asObservable();
+  folderViews$ = this._folderViews.asObservable();
+
+  constructor(
+    private cryptoService: CryptoService,
+    private i18nService: I18nService,
+    private cipherService: CipherService,
+    private stateService: StateService
+  ) {
+    this.stateService.activeAccountUnlocked$
+      .pipe(
+        concatMap(async (unlocked) => {
+          if (Utils.global.bitwardenContainerService == null) {
+            return;
+          }
+
+          if (!unlocked) {
+            this._folders.next([]);
+            this._folderViews.next([]);
+            return;
+          }
+
+          const data = await this.stateService.getEncryptedFolders();
+
+          await this.updateObservables(data);
+        })
+      )
+      .subscribe();
+  }
+
+  async clearCache(): Promise<void> {
+    this._folderViews.next([]);
+  }
+
+  // TODO: This should be moved to EncryptService or something
+  async encrypt(model: FolderView, key?: SymmetricCryptoKey): Promise<Folder> {
+    const folder = new Folder();
+    folder.id = model.id;
+    folder.name = await this.cryptoService.encrypt(model.name, key);
+    return folder;
+  }
+
+  async get(id: string): Promise<Folder> {
+    const folders = this._folders.getValue();
+
+    return folders.find((folder) => folder.id === id);
+  }
+
+  async getAllFromState(): Promise<Folder[]> {
+    const folders = await this.stateService.getEncryptedFolders();
+    const response: Folder[] = [];
+    for (const id in folders) {
+      // eslint-disable-next-line
+      if (folders.hasOwnProperty(id)) {
+        response.push(new Folder(folders[id]));
+      }
+    }
+    return response;
+  }
+
+  /**
+   * @deprecated For the CLI only
+   * @param id id of the folder
+   */
+  async getFromState(id: string): Promise<Folder> {
+    const foldersMap = await this.stateService.getEncryptedFolders();
+    const folder = foldersMap[id];
+    if (folder == null) {
+      return null;
+    }
+
+    return new Folder(folder);
+  }
+
+  /**
+   * @deprecated Only use in CLI!
+   */
+  async getAllDecryptedFromState(): Promise<FolderView[]> {
+    const data = await this.stateService.getEncryptedFolders();
+    const folders = Object.values(data || {}).map((f) => new Folder(f));
+
+    return this.decryptFolders(folders);
+  }
+
+  async upsert(folder: FolderData | FolderData[]): Promise<void> {
+    let folders = await this.stateService.getEncryptedFolders();
+    if (folders == null) {
+      folders = {};
+    }
+
+    if (folder instanceof FolderData) {
+      const f = folder as FolderData;
+      folders[f.id] = f;
+    } else {
+      (folder as FolderData[]).forEach((f) => {
+        folders[f.id] = f;
+      });
+    }
+
+    await this.updateObservables(folders);
+    await this.stateService.setEncryptedFolders(folders);
+  }
+
+  async replace(folders: { [id: string]: FolderData }): Promise<void> {
+    await this.updateObservables(folders);
+    await this.stateService.setEncryptedFolders(folders);
+  }
+
+  async clear(userId?: string): Promise<any> {
+    if (userId == null || userId == (await this.stateService.getUserId())) {
+      this._folders.next([]);
+      this._folderViews.next([]);
+    }
+    await this.stateService.setEncryptedFolders(null, { userId: userId });
+  }
+
+  async delete(id: string | string[]): Promise<any> {
+    const folders = await this.stateService.getEncryptedFolders();
+    if (folders == null) {
+      return;
+    }
+
+    if (typeof id === "string") {
+      if (folders[id] == null) {
+        return;
+      }
+      delete folders[id];
+    } else {
+      (id as string[]).forEach((i) => {
+        delete folders[i];
+      });
+    }
+
+    await this.updateObservables(folders);
+    await this.stateService.setEncryptedFolders(folders);
+
+    // Items in a deleted folder are re-assigned to "No Folder"
+    const ciphers = await this.stateService.getEncryptedCiphers();
+    if (ciphers != null) {
+      const updates: CipherData[] = [];
+      for (const cId in ciphers) {
+        if (ciphers[cId].folderId === id) {
+          ciphers[cId].folderId = null;
+          updates.push(ciphers[cId]);
+        }
+      }
+      if (updates.length > 0) {
+        this.cipherService.upsert(updates);
+      }
+    }
+  }
+
+  private async updateObservables(foldersMap: { [id: string]: FolderData }) {
+    const folders = Object.values(foldersMap || {}).map((f) => new Folder(f));
+
+    this._folders.next(folders);
+
+    if (await this.cryptoService.hasKey()) {
+      this._folderViews.next(await this.decryptFolders(folders));
+    }
+  }
+
+  private async decryptFolders(folders: Folder[]) {
+    const decryptFolderPromises = folders.map((f) => f.decrypt());
+    const decryptedFolders = await Promise.all(decryptFolderPromises);
+
+    decryptedFolders.sort(Utils.getSortFunction(this.i18nService, "name"));
+
+    const noneFolder = new FolderView();
+    noneFolder.name = this.i18nService.t("noneFolder");
+    decryptedFolders.push(noneFolder);
+
+    return decryptedFolders;
+  }
+}

libs/common/src/vault/services/sync/sync-notifier.service.ts

@@ -0,0 +1,18 @@
+import { Subject } from "rxjs";
+
+import { SyncNotifierService as SyncNotifierServiceAbstraction } from "../../abstractions/sync/sync-notifier.service.abstraction";
+import { SyncEventArgs } from "../../types/sync-event-args";
+
+/**
+ * This class should most likely have 0 dependencies because it will hopefully
+ * be rolled into SyncService once upon a time.
+ */
+export class SyncNotifierService implements SyncNotifierServiceAbstraction {
+  private _sync = new Subject<SyncEventArgs>();
+
+  sync$ = this._sync.asObservable();
+
+  next(event: SyncEventArgs): void {
+    this._sync.next(event);
+  }
+}

libs/common/src/vault/services/sync/sync.service.ts

@@ -0,0 +1,401 @@
+import { ApiService } from "../../../abstractions/api.service";
+import { CollectionService } from "../../../abstractions/collection.service";
+import { CryptoService } from "../../../abstractions/crypto.service";
+import { KeyConnectorService } from "../../../abstractions/keyConnector.service";
+import { LogService } from "../../../abstractions/log.service";
+import { MessagingService } from "../../../abstractions/messaging.service";
+import { InternalOrganizationService } from "../../../abstractions/organization/organization.service.abstraction";
+import { InternalPolicyService } from "../../../abstractions/policy/policy.service.abstraction";
+import { ProviderService } from "../../../abstractions/provider.service";
+import { SendService } from "../../../abstractions/send.service";
+import { SettingsService } from "../../../abstractions/settings.service";
+import { StateService } from "../../../abstractions/state.service";
+import { sequentialize } from "../../../misc/sequentialize";
+import { CollectionData } from "../../../models/data/collection.data";
+import { OrganizationData } from "../../../models/data/organization.data";
+import { PolicyData } from "../../../models/data/policy.data";
+import { ProviderData } from "../../../models/data/provider.data";
+import { SendData } from "../../../models/data/send.data";
+import { CollectionDetailsResponse } from "../../../models/response/collection.response";
+import { DomainsResponse } from "../../../models/response/domains.response";
+import {
+  SyncCipherNotification,
+  SyncFolderNotification,
+  SyncSendNotification,
+} from "../../../models/response/notification.response";
+import { PolicyResponse } from "../../../models/response/policy.response";
+import { ProfileResponse } from "../../../models/response/profile.response";
+import { SendResponse } from "../../../models/response/send.response";
+import { CipherService } from "../../../vault/abstractions/cipher.service";
+import { FolderApiServiceAbstraction } from "../../../vault/abstractions/folder/folder-api.service.abstraction";
+import { InternalFolderService } from "../../../vault/abstractions/folder/folder.service.abstraction";
+import { SyncService as SyncServiceAbstraction } from "../../../vault/abstractions/sync/sync.service.abstraction";
+import { CipherData } from "../../../vault/models/data/cipher.data";
+import { FolderData } from "../../../vault/models/data/folder.data";
+import { CipherResponse } from "../../../vault/models/response/cipher.response";
+import { FolderResponse } from "../../../vault/models/response/folder.response";
+
+export class SyncService implements SyncServiceAbstraction {
+  syncInProgress = false;
+
+  constructor(
+    private apiService: ApiService,
+    private settingsService: SettingsService,
+    private folderService: InternalFolderService,
+    private cipherService: CipherService,
+    private cryptoService: CryptoService,
+    private collectionService: CollectionService,
+    private messagingService: MessagingService,
+    private policyService: InternalPolicyService,
+    private sendService: SendService,
+    private logService: LogService,
+    private keyConnectorService: KeyConnectorService,
+    private stateService: StateService,
+    private providerService: ProviderService,
+    private folderApiService: FolderApiServiceAbstraction,
+    private organizationService: InternalOrganizationService,
+    private logoutCallback: (expired: boolean) => Promise<void>
+  ) {}
+
+  async getLastSync(): Promise<Date> {
+    if ((await this.stateService.getUserId()) == null) {
+      return null;
+    }
+
+    const lastSync = await this.stateService.getLastSync();
+    if (lastSync) {
+      return new Date(lastSync);
+    }
+
+    return null;
+  }
+
+  async setLastSync(date: Date, userId?: string): Promise<any> {
+    await this.stateService.setLastSync(date.toJSON(), { userId: userId });
+  }
+
+  @sequentialize(() => "fullSync")
+  async fullSync(forceSync: boolean, allowThrowOnError = false): Promise<boolean> {
+    this.syncStarted();
+    const isAuthenticated = await this.stateService.getIsAuthenticated();
+    if (!isAuthenticated) {
+      return this.syncCompleted(false);
+    }
+
+    const now = new Date();
+    let needsSync = false;
+    try {
+      needsSync = await this.needsSyncing(forceSync);
+    } catch (e) {
+      if (allowThrowOnError) {
+        throw e;
+      }
+    }
+
+    if (!needsSync) {
+      await this.setLastSync(now);
+      return this.syncCompleted(false);
+    }
+
+    try {
+      await this.apiService.refreshIdentityToken();
+      const response = await this.apiService.getSync();
+
+      await this.syncProfile(response.profile);
+      await this.syncFolders(response.folders);
+      await this.syncCollections(response.collections);
+      await this.syncCiphers(response.ciphers);
+      await this.syncSends(response.sends);
+      await this.syncSettings(response.domains);
+      await this.syncPolicies(response.policies);
+
+      await this.setLastSync(now);
+      return this.syncCompleted(true);
+    } catch (e) {
+      if (allowThrowOnError) {
+        throw e;
+      } else {
+        return this.syncCompleted(false);
+      }
+    }
+  }
+
+  async syncUpsertFolder(notification: SyncFolderNotification, isEdit: boolean): Promise<boolean> {
+    this.syncStarted();
+    if (await this.stateService.getIsAuthenticated()) {
+      try {
+        const localFolder = await this.folderService.get(notification.id);
+        if (
+          (!isEdit && localFolder == null) ||
+          (isEdit && localFolder != null && localFolder.revisionDate < notification.revisionDate)
+        ) {
+          const remoteFolder = await this.folderApiService.get(notification.id);
+          if (remoteFolder != null) {
+            await this.folderService.upsert(new FolderData(remoteFolder));
+            this.messagingService.send("syncedUpsertedFolder", { folderId: notification.id });
+            return this.syncCompleted(true);
+          }
+        }
+      } catch (e) {
+        this.logService.error(e);
+      }
+    }
+    return this.syncCompleted(false);
+  }
+
+  async syncDeleteFolder(notification: SyncFolderNotification): Promise<boolean> {
+    this.syncStarted();
+    if (await this.stateService.getIsAuthenticated()) {
+      await this.folderService.delete(notification.id);
+      this.messagingService.send("syncedDeletedFolder", { folderId: notification.id });
+      this.syncCompleted(true);
+      return true;
+    }
+    return this.syncCompleted(false);
+  }
+
+  async syncUpsertCipher(notification: SyncCipherNotification, isEdit: boolean): Promise<boolean> {
+    this.syncStarted();
+    if (await this.stateService.getIsAuthenticated()) {
+      try {
+        let shouldUpdate = true;
+        const localCipher = await this.cipherService.get(notification.id);
+        if (localCipher != null && localCipher.revisionDate >= notification.revisionDate) {
+          shouldUpdate = false;
+        }
+
+        let checkCollections = false;
+        if (shouldUpdate) {
+          if (isEdit) {
+            shouldUpdate = localCipher != null;
+            checkCollections = true;
+          } else {
+            if (notification.collectionIds == null || notification.organizationId == null) {
+              shouldUpdate = localCipher == null;
+            } else {
+              shouldUpdate = false;
+              checkCollections = true;
+            }
+          }
+        }
+
+        if (
+          !shouldUpdate &&
+          checkCollections &&
+          notification.organizationId != null &&
+          notification.collectionIds != null &&
+          notification.collectionIds.length > 0
+        ) {
+          const collections = await this.collectionService.getAll();
+          if (collections != null) {
+            for (let i = 0; i < collections.length; i++) {
+              if (notification.collectionIds.indexOf(collections[i].id) > -1) {
+                shouldUpdate = true;
+                break;
+              }
+            }
+          }
+        }
+
+        if (shouldUpdate) {
+          const remoteCipher = await this.apiService.getFullCipherDetails(notification.id);
+          if (remoteCipher != null) {
+            await this.cipherService.upsert(new CipherData(remoteCipher));
+            this.messagingService.send("syncedUpsertedCipher", { cipherId: notification.id });
+            return this.syncCompleted(true);
+          }
+        }
+      } catch (e) {
+        if (e != null && e.statusCode === 404 && isEdit) {
+          await this.cipherService.delete(notification.id);
+          this.messagingService.send("syncedDeletedCipher", { cipherId: notification.id });
+          return this.syncCompleted(true);
+        }
+      }
+    }
+    return this.syncCompleted(false);
+  }
+
+  async syncDeleteCipher(notification: SyncCipherNotification): Promise<boolean> {
+    this.syncStarted();
+    if (await this.stateService.getIsAuthenticated()) {
+      await this.cipherService.delete(notification.id);
+      this.messagingService.send("syncedDeletedCipher", { cipherId: notification.id });
+      return this.syncCompleted(true);
+    }
+    return this.syncCompleted(false);
+  }
+
+  async syncUpsertSend(notification: SyncSendNotification, isEdit: boolean): Promise<boolean> {
+    this.syncStarted();
+    if (await this.stateService.getIsAuthenticated()) {
+      try {
+        const localSend = await this.sendService.get(notification.id);
+        if (
+          (!isEdit && localSend == null) ||
+          (isEdit && localSend != null && localSend.revisionDate < notification.revisionDate)
+        ) {
+          const remoteSend = await this.apiService.getSend(notification.id);
+          if (remoteSend != null) {
+            await this.sendService.upsert(new SendData(remoteSend));
+            this.messagingService.send("syncedUpsertedSend", { sendId: notification.id });
+            return this.syncCompleted(true);
+          }
+        }
+      } catch (e) {
+        this.logService.error(e);
+      }
+    }
+    return this.syncCompleted(false);
+  }
+
+  async syncDeleteSend(notification: SyncSendNotification): Promise<boolean> {
+    this.syncStarted();
+    if (await this.stateService.getIsAuthenticated()) {
+      await this.sendService.delete(notification.id);
+      this.messagingService.send("syncedDeletedSend", { sendId: notification.id });
+      this.syncCompleted(true);
+      return true;
+    }
+    return this.syncCompleted(false);
+  }
+
+  // Helpers
+
+  private syncStarted() {
+    this.syncInProgress = true;
+    this.messagingService.send("syncStarted");
+  }
+
+  private syncCompleted(successfully: boolean): boolean {
+    this.syncInProgress = false;
+    this.messagingService.send("syncCompleted", { successfully: successfully });
+    return successfully;
+  }
+
+  private async needsSyncing(forceSync: boolean) {
+    if (forceSync) {
+      return true;
+    }
+
+    const lastSync = await this.getLastSync();
+    if (lastSync == null || lastSync.getTime() === 0) {
+      return true;
+    }
+
+    const response = await this.apiService.getAccountRevisionDate();
+    if (new Date(response) <= lastSync) {
+      return false;
+    }
+    return true;
+  }
+
+  private async syncProfile(response: ProfileResponse) {
+    const stamp = await this.stateService.getSecurityStamp();
+    if (stamp != null && stamp !== response.securityStamp) {
+      if (this.logoutCallback != null) {
+        await this.logoutCallback(true);
+      }
+
+      throw new Error("Stamp has changed");
+    }
+
+    await this.cryptoService.setEncKey(response.key);
+    await this.cryptoService.setEncPrivateKey(response.privateKey);
+    await this.cryptoService.setProviderKeys(response.providers);
+    await this.cryptoService.setOrgKeys(response.organizations, response.providerOrganizations);
+    await this.stateService.setAvatarColor(response.avatarColor);
+    await this.stateService.setSecurityStamp(response.securityStamp);
+    await this.stateService.setEmailVerified(response.emailVerified);
+    await this.stateService.setHasPremiumPersonally(response.premiumPersonally);
+    await this.stateService.setHasPremiumFromOrganization(response.premiumFromOrganization);
+    await this.stateService.setForcePasswordReset(response.forcePasswordReset);
+    await this.keyConnectorService.setUsesKeyConnector(response.usesKeyConnector);
+
+    const organizations: { [id: string]: OrganizationData } = {};
+    response.organizations.forEach((o) => {
+      organizations[o.id] = new OrganizationData(o);
+    });
+
+    const providers: { [id: string]: ProviderData } = {};
+    response.providers.forEach((p) => {
+      providers[p.id] = new ProviderData(p);
+    });
+
+    response.providerOrganizations.forEach((o) => {
+      if (organizations[o.id] == null) {
+        organizations[o.id] = new OrganizationData(o);
+        organizations[o.id].isProviderUser = true;
+      }
+    });
+
+    await this.organizationService.replace(organizations);
+    await this.providerService.save(providers);
+
+    if (await this.keyConnectorService.userNeedsMigration()) {
+      await this.keyConnectorService.setConvertAccountRequired(true);
+      this.messagingService.send("convertAccountToKeyConnector");
+    } else {
+      this.keyConnectorService.removeConvertAccountRequired();
+    }
+  }
+
+  private async syncFolders(response: FolderResponse[]) {
+    const folders: { [id: string]: FolderData } = {};
+    response.forEach((f) => {
+      folders[f.id] = new FolderData(f);
+    });
+    return await this.folderService.replace(folders);
+  }
+
+  private async syncCollections(response: CollectionDetailsResponse[]) {
+    const collections: { [id: string]: CollectionData } = {};
+    response.forEach((c) => {
+      collections[c.id] = new CollectionData(c);
+    });
+    return await this.collectionService.replace(collections);
+  }
+
+  private async syncCiphers(response: CipherResponse[]) {
+    const ciphers: { [id: string]: CipherData } = {};
+    response.forEach((c) => {
+      ciphers[c.id] = new CipherData(c);
+    });
+    return await this.cipherService.replace(ciphers);
+  }
+
+  private async syncSends(response: SendResponse[]) {
+    const sends: { [id: string]: SendData } = {};
+    response.forEach((s) => {
+      sends[s.id] = new SendData(s);
+    });
+    return await this.sendService.replace(sends);
+  }
+
+  private async syncSettings(response: DomainsResponse) {
+    let eqDomains: string[][] = [];
+    if (response != null && response.equivalentDomains != null) {
+      eqDomains = eqDomains.concat(response.equivalentDomains);
+    }
+
+    if (response != null && response.globalEquivalentDomains != null) {
+      response.globalEquivalentDomains.forEach((global) => {
+        if (global.domains.length > 0) {
+          eqDomains.push(global.domains);
+        }
+      });
+    }
+
+    return this.settingsService.setEquivalentDomains(eqDomains);
+  }
+
+  private async syncPolicies(response: PolicyResponse[]) {
+    const policies: { [id: string]: PolicyData } = {};
+    if (response != null) {
+      response.forEach((p) => {
+        policies[p.id] = new PolicyData(p);
+      });
+    }
+    return await this.policyService.replace(policies);
+  }
+}