feat: 🎸 refactor FacilityService.ts and UserService.ts

windingtree · Jun 6, 2022 · a564a5a · a564a5a
1 parent 98be7c6
commit a564a5a
Show file tree

Hide file tree

Showing 7 changed files with 233 additions and 176 deletions.
diff --git a/src/middlewares/AuthMiddleware.ts b/src/middlewares/AuthMiddleware.ts
@@ -1,6 +1,7 @@
 import ApiError from '../exceptions/ApiError';
 import tokenService from '../services/TokenService';
 import userService from '../services/UserService';
+import userRepository from '../repositories/UserRepository';
 import { UserDTO } from '../types';
 
 export default async (req, res, next) => {
@@ -21,13 +22,13 @@ export default async (req, res, next) => {
       return next(ApiError.UnauthorizedError());
     }
 
-    const userExists = await userService.getUserIdByLogin(userData.login);
+    const userExists = await userRepository.getUserIdByLogin(userData.login);
 
     if (!userExists) {
       return next(ApiError.UnauthorizedError());
     }
 
-    const user = await userService.getUserById(userData.id);
+    const user = await userRepository.getUserById(userData.id);
     req.user = userService.getUserDTO(user);
     next();
   } catch (e) {

diff --git a/src/repositories/FacilityRepository.ts b/src/repositories/FacilityRepository.ts
@@ -1,6 +1,6 @@
-import DBService from '../services/DBService';
+import DBService, { FacilityItemType, FacilityLevelValues, FacilitySpaceLevelValues } from '../services/DBService';
 import { Level } from 'level';
-import { Facility } from '../proto/facility';
+import { Item } from '../proto/facility';
 
 export class FacilityRepository {
   private dbService: DBService;
@@ -24,26 +24,110 @@ export class FacilityRepository {
     return [];
   }
 
-  public async createFacility(
+  public async createFacilityIndex(facilityId: string) {
+    const facilitiesIds = await this.getFacilityIds();
+
+    if (facilitiesIds.length > 0) {
+      const idsSet = new Set<string>(facilitiesIds);
+      idsSet.add(facilityId);
+      await this.db.put('facilities', Array.from(idsSet));
+    } else {
+      await this.db.put('facilities', [facilityId]);
+    }
+  }
+
+  public async getItemIds(
+    facilityId: string,
+    itemType: FacilityItemType
+  ): Promise<string[]> {
+    try {
+      const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
+      return await facilitySublevel.get<string, string[]>(itemType, {
+        valueEncoding: 'json'
+      });
+    } catch (e) {
+      if (e.status !== 404) {
+        throw e;
+      }
+    }
+    return [];
+  }
+
+  public async createFacilityItem(
     facilityId: string,
-    facility: Facility
+    key: string,
+    value: FacilityLevelValues
   ): Promise<void> {
     const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
 
-    await facilitySublevel.put('metadata', facility);
+    await facilitySublevel.put(key, value);
+  }
 
-    await this.createFacilityIndex(facilityId);
+  public async getFacilityDbKey(
+    facilityId: string,
+    key: string
+  ): Promise<FacilityLevelValues> {
+    try {
+      return await this.dbService.getFacilitySublevelDB(facilityId).get(key);
+    } catch (e) {
+      if (e.status === 404) {
+        throw new Error(`Unable to get "${key}" of facility "${facilityId}"`);
+      }
+      throw e;
+    }
   }
 
-  private async createFacilityIndex(facilityId: string) {
-    const facilitiesIds = await this.getFacilityIds();
+  public async getSpaceDbKey(
+    facilityId: string,
+    spaceId: string,
+    key: string
+  ): Promise<FacilitySpaceLevelValues> {
+    try {
+      return await this.dbService
+        .getFacilityItemDB(facilityId, 'spaces', spaceId)
+        .get(key);
+    } catch (e) {
+      if (e.status === 404) {
+        throw new Error(
+          `Unable to get "${key}" of space "${spaceId}" of facility "${facilityId}"`
+        );
+      }
+      throw e;
+    }
+  }
 
-    if (facilitiesIds.length > 0) {
-      const idsSet = new Set<string>(facilitiesIds);
-      idsSet.add(facilityId);
-      await this.db.put('facilities', Array.from(idsSet));
+  public async createSpaceIndex(
+    facilityId: string,
+    itemType: FacilityItemType,
+    itemId: string
+  ): Promise<void> {
+    const itemIds = await this.getItemIds(facilityId, itemType);
+    const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
+
+    if (itemIds.length > 0) {
+      const spaceSet = new Set<string>(itemIds);
+      spaceSet.add(itemId);
+      await facilitySublevel.put(itemType, Array.from(spaceSet));
     } else {
-      await this.db.put('facilities', [facilityId]);
+      await facilitySublevel.put(itemType, [itemId]);
     }
   }
+
+  public async createSpaceItem(
+    facilityId: string,
+    itemType: FacilityItemType,
+    itemId: string,
+    key: string,
+    value: Item | FacilitySpaceLevelValues
+  ): Promise<void> {
+    const sublevel = this.dbService.getFacilityItemDB(
+      facilityId,
+      itemType,
+      itemId
+    );
+
+    await sublevel.put(key, value);
+  }
 }
+
+export default new FacilityRepository();
diff --git a/src/repositories/MainRepository.ts b/src/repositories/MainRepository.ts
@@ -0,0 +1,29 @@
+import DBService from '../services/DBService';
+import { Level } from 'level';
+
+export class MainRepository {
+  private dbService: DBService;
+  private db: Level<string, string | string[]>;
+
+  constructor() {
+    this.dbService = DBService.getInstance();
+    this.db = DBService.getInstance().getDB();
+  }
+
+  public async getId(): Promise<number> {
+    try {
+      return (Number(await this.db.get('user_db_increment'))) + 1;
+    } catch (e) {
+      if (e.status === 404) {
+        return 1;
+      }
+      throw e;
+    }
+  }
+
+  public async setUserDBIncrement(id: string) {
+    await this.db.put('user_db_increment', id);
+  }
+}
+
+export default new MainRepository();
diff --git a/src/repositories/UserRepository.ts b/src/repositories/UserRepository.ts
@@ -0,0 +1,66 @@
+import { AppRole, User } from '../types';
+import DBService, { DBLevel, LevelDefaultTyping } from '../services/DBService';
+import { Level } from 'level';
+import { AbstractSublevel } from 'abstract-level';
+
+export class UserRepository {
+  private dbService: DBService;
+  private db: Level<string, string | string[]>;
+  private userDB: AbstractSublevel<DBLevel, LevelDefaultTyping, string, User>;
+  private loginDB: AbstractSublevel<DBLevel, LevelDefaultTyping, string, string>;
+
+  constructor() {
+    this.dbService = DBService.getInstance();
+    this.db = DBService.getInstance().getDB();
+    this.userDB = DBService.getInstance().getUserDB();
+    this.loginDB = this.dbService.getLoginDB();
+  }
+
+
+  public async getAllUsers(): Promise<User[]> {
+    return await this.userDB.values().all();
+  }
+
+  public async getUserIdByLogin(login: string): Promise<number | null> {
+    try {
+      const userId = await this.loginDB.get(login);
+      return Number(userId);
+    } catch (e) {
+      if (e.status === 404) {
+        return null;
+      }
+      throw e;
+    }
+  }
+
+  public async getUserById(id: number): Promise<User> {
+    return await this.userDB.get(String(id));
+  }
+
+  public async createUser(
+    id: number,
+    login: string,
+    password: string,
+    roles: AppRole[]
+  ): Promise<void> {
+    await this.userDB.put(String(id), {
+      id,
+      login,
+      password,
+      roles
+    });
+
+    await this.loginDB.put(login, String(id));
+  }
+
+  public async deleteUser(userId: string, login: string): Promise<void> {
+    await this.db.del(String(userId));
+    await this.loginDB.del(login);
+  }
+
+  public async updateUser(userId: string, user: User): Promise<void> {
+    await this.userDB.put(String(userId), user);
+  }
+}
+
+export default new UserRepository();
diff --git a/src/services/FacilityService.ts b/src/services/FacilityService.ts
@@ -1,101 +1,23 @@
-import { Level } from 'level';
 import { Item } from '../proto/facility';
-import DBService, {
-  FacilityItemType,
-  FacilityLevelValues,
-  FacilitySpaceLevelValues
-} from './DBService';
+import { FacilityItemType, FacilityLevelValues, FacilitySpaceLevelValues } from './DBService';
+import facilityRepository, { FacilityRepository } from '../repositories/FacilityRepository';
 
 export class FacilityService {
-  private dbService: DBService;
-  private db: Level<string, string | string[]>;
+  private repository: FacilityRepository;
 
   constructor() {
-    this.dbService = DBService.getInstance();
-    this.db = this.dbService.getDB();
-  }
-
-  public async getFacilityIds(): Promise<string[]> {
-    try {
-      return await this.db.get<string, string[]>('facilities', {
-        valueEncoding: 'json'
-      });
-    } catch (e) {
-      if (e.status !== 404) {
-        throw e;
-      }
-    }
-    return [];
-  }
-
-  public async getItemIds(
-    facilityId: string,
-    itemType: FacilityItemType
-  ): Promise<string[]> {
-    try {
-      const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
-      return await facilitySublevel.get<string, string[]>(itemType, {
-        valueEncoding: 'json'
-      });
-    } catch (e) {
-      if (e.status !== 404) {
-        throw e;
-      }
-    }
-    return [];
-  }
-
-  public async getFacilityDbKey(
-    facilityId: string,
-    key: string
-  ): Promise<FacilityLevelValues> {
-    try {
-      return await this.dbService.getFacilitySublevelDB(facilityId).get(key);
-    } catch (e) {
-      if (e.status === 404) {
-        throw new Error(`Unable to get "${key}" of facility "${facilityId}"`);
-      }
-      throw e;
-    }
-  }
-
-  public async getSpaceDbKey(
-    facilityId: string,
-    spaceId: string,
-    key: string
-  ): Promise<FacilitySpaceLevelValues> {
-    try {
-      return await this.dbService
-        .getFacilityItemDB(facilityId, 'spaces', spaceId)
-        .get(key);
-    } catch (e) {
-      if (e.status === 404) {
-        throw new Error(
-          `Unable to get "${key}" of space "${spaceId}" of facility "${facilityId}"`
-        );
-      }
-      throw e;
-    }
+    this.repository = facilityRepository;
   }
 
   public async setFacilityDbKeys(
     facilityId: string,
     entries: [string, FacilityLevelValues][]
   ): Promise<void> {
-    const ids = await this.getFacilityIds();
-
-    if (ids.length > 0) {
-      const idsSet = new Set<string>(ids);
-      idsSet.add(facilityId);
-      await this.db.put('facilities', Array.from(idsSet));
-    } else {
-      await this.db.put('facilities', [facilityId]);
-    }
-
-    const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
+    await this.repository.createFacilityIndex(facilityId);
 
     await Promise.all(
-      entries.map(([key, value]) => facilitySublevel.put(key, value))
+      entries.map(([key, value]) =>
+        this.repository.createFacilityItem(facilityId, key, value))
     );
   }
 
@@ -105,24 +27,10 @@ export class FacilityService {
     itemId: string,
     entries: [string, Item | FacilitySpaceLevelValues][]
   ): Promise<void> {
-    const itemIds = await this.getItemIds(facilityId, itemType);
-    const facilitySublevel = this.dbService.getFacilitySublevelDB(facilityId);
-
-    if (itemIds.length > 0) {
-      const spaceSet = new Set<string>(itemIds);
-      spaceSet.add(itemId);
-      await facilitySublevel.put(itemType, Array.from(spaceSet));
-    } else {
-      await facilitySublevel.put(itemType, [itemId]);
-    }
-
-    const sublevel = this.dbService.getFacilityItemDB(
-      facilityId,
-      itemType,
-      itemId
-    );
+    await this.repository.createSpaceIndex(facilityId, itemType, itemId);
 
-    await Promise.all(entries.map(([key, value]) => sublevel.put(key, value)));
+    await Promise.all(entries.map(([key, value]) =>
+      this.repository.createSpaceItem(facilityId, itemType, itemId, key, value)));
   }
 }