move folder service to jslib

src/abstractions/folder.service.ts

@@ -0,0 +1,19 @@
+import { FolderData } from '../models/data';
+
+import { Folder } from '../models/domain';
+
+export interface FolderService {
+    decryptedFolderCache: any[];
+
+    clearCache(): void;
+    encrypt(model: any): Promise<Folder>;
+    get(id: string): Promise<Folder>;
+    getAll(): Promise<Folder[]>;
+    getAllDecrypted(): Promise<any[]>;
+    saveWithServer(folder: Folder): Promise<any>;
+    upsert(folder: FolderData | FolderData[]): Promise<any>;
+    replace(folders: { [id: string]: FolderData; }): Promise<any>;
+    clear(userId: string): Promise<any>;
+    delete(id: string | string[]): Promise<any>;
+    deleteWithServer(id: string): Promise<any>;
+}

src/abstractions/index.ts

@@ -2,6 +2,7 @@ export { ApiService } from './api.service';
 export { AppIdService } from './appId.service';
 export { CryptoService } from './crypto.service';
 export { EnvironmentService } from './environment.service';
+export { FolderService } from './folder.service';
 export { MessagingService } from './messaging.service';
 export { PasswordGenerationService } from './passwordGeneration.service';
 export { PlatformUtilsService } from './platformUtils.service';

src/services/folder.service.ts

@@ -0,0 +1,163 @@
+import { FolderData } from '../models/data';
+
+import { Folder } from '../models/domain';
+
+import { FolderRequest } from '../models/request';
+
+import { FolderResponse } from '../models/response';
+
+import { ApiService } from '../abstractions/api.service';
+import { CryptoService } from '../abstractions/crypto.service';
+import { FolderService as FolderServiceInterface } from '../abstractions/folder.service';
+import { StorageService } from '../abstractions/storage.service';
+import { UserService } from '../abstractions/user.service';
+
+const Keys = {
+    foldersPrefix: 'folders_',
+};
+
+export class FolderService implements FolderServiceInterface {
+    decryptedFolderCache: any[];
+
+    constructor(private cryptoService: CryptoService, private userService: UserService,
+        private noneFolder: string, private apiService: ApiService,
+        private storageService: StorageService) {
+    }
+
+    clearCache(): void {
+        this.decryptedFolderCache = null;
+    }
+
+    async encrypt(model: any): Promise<Folder> {
+        const folder = new Folder();
+        folder.id = model.id;
+        folder.name = await this.cryptoService.encrypt(model.name);
+        return folder;
+    }
+
+    async get(id: string): Promise<Folder> {
+        const userId = await this.userService.getUserId();
+        const folders = await this.storageService.get<{ [id: string]: FolderData; }>(
+            Keys.foldersPrefix + userId);
+        if (folders == null || !folders.hasOwnProperty(id)) {
+            return null;
+        }
+
+        return new Folder(folders[id]);
+    }
+
+    async getAll(): Promise<Folder[]> {
+        const userId = await this.userService.getUserId();
+        const folders = await this.storageService.get<{ [id: string]: FolderData; }>(
+            Keys.foldersPrefix + userId);
+        const response: Folder[] = [];
+        for (const id in folders) {
+            if (folders.hasOwnProperty(id)) {
+                response.push(new Folder(folders[id]));
+            }
+        }
+        return response;
+    }
+
+    async getAllDecrypted(): Promise<any[]> {
+        if (this.decryptedFolderCache != null) {
+            return this.decryptedFolderCache;
+        }
+
+        const decFolders: any[] = [{
+            id: null,
+            name: this.noneFolder,
+        }];
+
+        const key = await this.cryptoService.getKey();
+        if (key == null) {
+            throw new Error('No key.');
+        }
+
+        const promises: Array<Promise<any>> = [];
+        const folders = await this.getAll();
+        folders.forEach((folder) => {
+            promises.push(folder.decrypt().then((f: any) => {
+                decFolders.push(f);
+            }));
+        });
+
+        await Promise.all(promises);
+        this.decryptedFolderCache = decFolders;
+        return this.decryptedFolderCache;
+    }
+
+    async saveWithServer(folder: Folder): Promise<any> {
+        const request = new FolderRequest(folder);
+
+        let response: FolderResponse;
+        if (folder.id == null) {
+            response = await this.apiService.postFolder(request);
+            folder.id = response.id;
+        } else {
+            response = await this.apiService.putFolder(folder.id, request);
+        }
+
+        const userId = await this.userService.getUserId();
+        const data = new FolderData(response, userId);
+        await this.upsert(data);
+    }
+
+    async upsert(folder: FolderData | FolderData[]): Promise<any> {
+        const userId = await this.userService.getUserId();
+        let folders = await this.storageService.get<{ [id: string]: FolderData; }>(
+            Keys.foldersPrefix + userId);
+        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.storageService.save(Keys.foldersPrefix + userId, folders);
+        this.decryptedFolderCache = null;
+    }
+
+    async replace(folders: { [id: string]: FolderData; }): Promise<any> {
+        const userId = await this.userService.getUserId();
+        await this.storageService.save(Keys.foldersPrefix + userId, folders);
+        this.decryptedFolderCache = null;
+    }
+
+    async clear(userId: string): Promise<any> {
+        await this.storageService.remove(Keys.foldersPrefix + userId);
+        this.decryptedFolderCache = null;
+    }
+
+    async delete(id: string | string[]): Promise<any> {
+        const userId = await this.userService.getUserId();
+        const folders = await this.storageService.get<{ [id: string]: FolderData; }>(
+            Keys.foldersPrefix + userId);
+        if (folders == null) {
+            return;
+        }
+
+        if (typeof id === 'string') {
+            const i = id as string;
+            delete folders[id];
+        } else {
+            (id as string[]).forEach((i) => {
+                delete folders[i];
+            });
+        }
+
+        await this.storageService.save(Keys.foldersPrefix + userId, folders);
+        this.decryptedFolderCache = null;
+    }
+
+    async deleteWithServer(id: string): Promise<any> {
+        await this.apiService.deleteFolder(id);
+        await this.delete(id);
+    }
+}

src/services/index.ts

@@ -4,6 +4,7 @@ export { ConstantsService } from './constants.service';
 export { ContainerService } from './container.service';
 export { CryptoService } from './crypto.service';
 export { EnvironmentService } from './environment.service';
+export { FolderService } from './folder.service';
 export { PasswordGenerationService } from './passwordGeneration.service';
 export { TokenService } from './token.service';
 export { TotpService } from './totp.service';