Merge pull request #280 from SCVApp/master

api so user can have multiple lockers

Author: urbankrepel

db_migrations/locker_function.sql

@@ -7,6 +7,12 @@ BEGIN
         END IF;
     END IF;
 
+    -- Check if user has reached the maximum number of lockers
+    IF (TG_OP IN ('INSERT', 'UPDATE') AND (OLD.user_id IS NULL OR NEW.user_id != OLD.user_id OR OLD.locker_id IS NULL OR NEW.locker_id != OLD.locker_id)) THEN
+        IF (SELECT COUNT(*) FROM lockers_users WHERE user_id = NEW.user_id AND start_time < NOW() AND (end_time IS NULL OR end_time > NOW())) >= 2 THEN
+            RAISE EXCEPTION 'The user have reached the maximum number of lockers';
+        END IF;
+    END IF;
     RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;

src/lockers/lockers.controller.ts

@@ -33,7 +33,7 @@ export class LockersController {
   async getUserLocker(@Req() req: Request, @Res() res: Response) {
     const userAzureId: string = req.body.azure_id;
     const userAccessToken: string = req.body.access_token;
-    const locker = await this.lockersService.getUserLocker(
+    const locker = await this.lockersService.getUserLockers(
       userAzureId,
       userAccessToken,
     );
@@ -94,11 +94,15 @@ export class LockersController {
   User requests to end locker session if user currently has a locker assigned to him it will be opened and end the session so locker can be used by other users
   */
   @Post('end')
-  async endLocker(@Req() req: Request, @Res() res: Response) {
-    const userAzureId = req.body.azure_id;
-    const userAccessToken = req.body.access_token;
+  async endLocker(@Body() data: OpenLockerDto, @Res() res: Response) {
+    const userAzureId = data.azure_id;
+    const userAccessToken = data.access_token;
 
-    await this.lockersService.endLocker(userAzureId, userAccessToken);
+    await this.lockersService.endLocker(
+      userAzureId,
+      userAccessToken,
+      data.lockerId,
+    );
 
     return res.status(200).json({ message: 'Locker session ended' });
   }

src/lockers/lockers.service.ts

@@ -81,35 +81,71 @@ export class LockersService {
     return await this.lockerRepository.findOne({ where: { id } });
   }
 
-  async getUserLocker(userAzureId: string, userAccessToken: string) {
+  async getUserLockers(userAzureId: string, userAccessToken: string) {
     const user: UserPassEntity = await this.passService.getUserFromAzureId(
       userAzureId,
       userAccessToken,
     );
     if (!user) {
       throw new NotFoundException('User not found');
     }
-    return await this.getUsersActiveLocker(user);
+    return await this.getUsersActiveLockers(user, false);
   }
 
-  async getUsersActiveLocker(
+  async getUsersActiveLockers(
     user: UserPassEntity,
-  ): Promise<LockerEntity | null> {
-    const locker = await this.lockersUsersRepository
+    countOnly: true,
+  ): Promise<number>;
+  async getUsersActiveLockers(
+    user: UserPassEntity,
+    countOnly: false,
+  ): Promise<LockerEntity[]>;
+
+  async getUsersActiveLockers(
+    user: UserPassEntity,
+    countOnly: boolean,
+  ): Promise<LockerEntity[] | number> {
+    const data = this.lockersUsersRepository
       .createQueryBuilder('lockers_users')
       .select('locker_id')
       .where('user_id = :user_id', { user_id: user.id })
       .andWhere('start_time < NOW()')
       .andWhere('(end_time > NOW() OR end_time IS NULL)')
-      .orderBy('start_time', 'DESC')
-      .limit(1)
-      .getRawOne();
+      .orderBy('start_time', 'DESC');
 
-    if (!locker || !locker.locker_id) {
-      return null;
+    if (countOnly) {
+      return await data.getCount();
     }
 
-    return await this.getLockerById(locker.locker_id);
+    const lockers = await data.getRawMany();
+    const promises = lockers.map((locker) =>
+      this.getLockerById(locker.locker_id),
+    );
+    const result = await Promise.allSettled(promises);
+
+    return result
+      .map((r) => {
+        if (r.status === 'fulfilled') {
+          return r.value;
+        }
+        return null;
+      })
+      .filter((r): r is LockerEntity => r !== null);
+  }
+
+  async isUserUsingLocker(
+    user: UserPassEntity,
+    lockerId: number,
+  ): Promise<boolean> {
+    const result: number = await this.lockersUsersRepository
+      .createQueryBuilder('lu')
+      .where('lu.user_id = :user_id', { user_id: user.id })
+      .andWhere('lu.locker_id = :locker_id', { locker_id: lockerId })
+      .andWhere('lu.start_time < NOW()')
+      .andWhere('(lu.end_time > NOW() OR lu.end_time IS NULL)')
+      .getCount();
+
+    return result > 0;
   }
 
   // Open locker or assign locker to
@@ -125,14 +161,20 @@ export class LockersService {
     if (!user) {
       throw new NotFoundException('User not found');
     }
-    const activeLocker = await this.getUsersActiveLocker(user);
-    if (activeLocker) {
-      const success = await this.openLocker(activeLocker);
-      if (!success) {
-        throw new InternalServerErrorException('Failed to open locker');
-      }
+
+    // Check if user is already using locker
+    const isUserUsingLocker = await this.isUserUsingLocker(user, lockerId);
+    if (isUserUsingLocker) {
+      await this.openLockerById(lockerId);
       return;
     }
+
+    // Check if user lockers limit is reached
+    const userLockersCount = await this.getUsersActiveLockers(user, true);
+    if (userLockersCount >= 2) {
+      throw new NotFoundException('You have reached the limit of lockers');
+    }
+
     const selectedLocker = await this.getLockerById(lockerId);
     if (!selectedLocker) {
       throw new NotFoundException('Locker not found');
@@ -163,18 +205,29 @@ export class LockersService {
   }
 
   // End locker session
-  async endLocker(userAzureId: string, userAccessToken: string) {
+  async endLocker(
+    userAzureId: string,
+    userAccessToken: string,
+    lockerId: number,
+  ) {
     const user: UserPassEntity = await this.passService.getUserFromAzureId(
       userAzureId,
       userAccessToken,
     );
     if (!user) {
       throw new NotFoundException('User not found');
     }
-    const activeLocker = await this.getUsersActiveLocker(user);
+
+    const isUserUsingLocker = await this.isUserUsingLocker(user, lockerId);
+    if (!isUserUsingLocker) {
+      throw new NotFoundException('User is not using this locker');
+    }
+
+    const activeLocker = await this.getLockerById(lockerId);
     if (!activeLocker) {
-      throw new NotFoundException('User does not have an active locker');
+      throw new NotFoundException('Locker not found');
     }
+
     const success = await this.openLocker(activeLocker);
     if (!success) {
       throw new InternalServerErrorException('Failed to open locker');