Implement banUser function

src/auth/auth.service.ts

@@ -15,7 +15,7 @@
 } from './auth.pb';
 import { RpcException } from '@nestjs/microservices';
 import { status } from '@grpc/grpc-js';
 import { GrpcPermissionDeniedException } from 'nestjs-grpc-exceptions';
 import { v4 as uuidv4 } from 'uuid';
 import { Role } from '@prisma/client';
 
@@ -48,7 +48,7 @@
       }
 
       const { accessToken, refreshToken } = await this.getTokens(user.id);
-      user = await this.userRepo.updateRefreshToken(user.id, refreshToken);
+      user = await this.userRepo.update(user.id, { refreshToken: refreshToken });
       if (!user) {
         throw new RpcException({
           code: status.INTERNAL,
@@ -79,7 +79,7 @@
   public async refreshToken(
     request: RefreshTokenRequest,
   ): Promise<RefreshTokenResponse> {
     return null;
   }
 
   private async getTokens(userId: string) {

src/model/user.dto.ts

@@ -0,0 +1,13 @@
+import { Status } from "@prisma/client";
+
+export interface User{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    firstName: string;
+    lastName: string;
+    email: string;
+    phoneNumber: string;
+    role: string;
+    status: Status;
+}

src/repository/user.repository.ts

@@ -1,26 +1,16 @@
-import { Injectable } from '@nestjs/common';
-import { PrismaClient, User } from '@prisma/client';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { PrismaClient, Status, User } from '@prisma/client';
 import { PrismaService } from '../prisma/service/prisma.service';
 import { Prisma } from '@prisma/client';
 
 @Injectable()
 export class UserRepository {
-  constructor(private db: PrismaService) { }
+  constructor(private db: PrismaService) {}
 
   async getUserByEmail(email: string): Promise<User> {
     return this.db.user.findUnique({ where: { email: email } });
   }
 
-  async updateRefreshToken(
-    userId: string,
-    refreshToken: string,
-  ): Promise<User> {
-    return await this.db.user.update({
-      where: { id: userId },
-      data: { refreshToken: refreshToken },
-    });
-  }
-
   async create(createUser: Prisma.UserCreateInput): Promise<User> {
     return await this.db.user.create({
       data: {
@@ -35,6 +25,22 @@
     });
   }
 
+  async findUserById(userId: string): Promise<User> {
+    return await this.db.user.findUnique({
+      where: { id: userId },
+    });
+  }
+
+  async update(
+    userId: string,
+    updateUser: Prisma.UserUpdateInput,
+  ): Promise<User> {
+    return await this.db.user.update({
+      where: { id: userId },
+      data: updateUser,
+    });
+  }
+
   async getAllUsers(): Promise<object[]> {
     return this.db.user.findMany({
       select: {
@@ -46,8 +52,8 @@
         role: true,
         password: false,
         refreshToken: false,
-        status: true
-      }
+        status: true,
+      },
     });
   }
 

src/user/user.controller.spec.ts

@@ -5,14 +5,15 @@ import { UserService } from './user.service';
 describe('UserController', () => {
   let controller: UserController;
   const mockUserService = {
-    findUserById: jest.fn(),
-    update: jest.fn(),
-    exclude: jest.fn(),
+    findAllUsers: jest.fn(),
+    banUser: jest.fn(),
+    unbanUser: jest.fn(),
   };
+
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [UserController],
-      providers: [{ provide: UserService, useValue: mockUserService }]
+      providers: [{ provide: UserService, useValue: mockUserService }],
     }).compile();
 
     controller = module.get<UserController>(UserController);

src/user/user.controller.ts

@@ -1,5 +1,6 @@
-import { Controller, Get, Patch } from '@nestjs/common';
+import { Controller, Get, Param, Patch } from '@nestjs/common';
 import { UserService } from './user.service';
+import { User } from 'src/model/user.dto';
 
 @Controller('user')
 export class UserController {
@@ -11,8 +12,8 @@ export class UserController {
   }
 
   @Patch('ban/:userId')
-  banUser() {
-    return null;
+  banUser(@Param('userId') userId: string) : Promise<User>{
+    return this.userService.banUser(userId);
   }
 
   @Patch('unban/:userId')

src/user/user.service.spec.ts

@@ -12,10 +12,13 @@ describe('UserService', () => {
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [UserService, {
-        provide: UserRepository,
-        useValue: mockUserRepository,
-      },],
+      providers: [
+        UserService,
+        {
+          provide: UserRepository,
+          useValue: mockUserRepository,
+        },
+      ],
     }).compile();
 
     service = module.get<UserService>(UserService);

src/user/user.service.ts

@@ -1,5 +1,6 @@
-import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import { Injectable, NotFoundException, InternalServerErrorException } from '@nestjs/common';
 import { UserRepository } from '../repository/user.repository';
+import { Status } from '@prisma/client';
 
 @Injectable()
 export class UserService {
@@ -15,15 +16,27 @@ export class UserService {
     }
   }
 
-  banUser() {
-    return null;
+  async banUser(userId: string) {
+    try {
+      const user = await this.userRepo.findUserById(userId);
+      if(!user){
+        throw new NotFoundException(`User with id ${userId} not found`);
+      }
+      if(user.status === Status.BANNED){
+        return this.userRepo.exclude(user, ['password', 'refreshToken']);;
+      }
+      const bannedUser = await this.userRepo.update(userId, {
+        status: Status.BANNED,
+      });      
+      return this.userRepo.exclude(bannedUser, ['password', 'refreshToken']);
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
   }
 
   unbanUser() {
     return null;
   }
 }
-function exclude(allUsers: Promise<{ id: string; createdAt: Date; updatedAt: Date; firstName: string; lastName: string; email: string; phoneNumber: string; password: string; role: import(".prisma/client").$Enums.Role; refreshToken: string; }[]>) {
-  throw new Error('Function not implemented.');
-}