[backend] mute user in room

backend/prisma/migrations/20240118204714_add_mute_user_on_room_model/migration.sql

@@ -0,0 +1,16 @@
+-- CreateTable
+CREATE TABLE "MuteUserOnRoom" (
+    "userId" INTEGER NOT NULL,
+    "roomId" INTEGER NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "expiresAt" TIMESTAMP(3)
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "MuteUserOnRoom_userId_roomId_key" ON "MuteUserOnRoom"("userId", "roomId");
+
+-- AddForeignKey
+ALTER TABLE "MuteUserOnRoom" ADD CONSTRAINT "MuteUserOnRoom_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "MuteUserOnRoom" ADD CONSTRAINT "MuteUserOnRoom_roomId_fkey" FOREIGN KEY ("roomId") REFERENCES "Room"("id") ON DELETE CASCADE ON UPDATE CASCADE;

backend/prisma/schema.prisma

@@ -42,6 +42,7 @@ model User {
   twoFactorEnabled Boolean         @default(false)
   Message          Message[]
   BannedRooms      BanUserOnRoom[]
+  MutedRooms       MuteUserOnRoom[]
 }
 
 model Room {
@@ -52,6 +53,7 @@ model Room {
   accessLevel AccessLevel
   password    String?
   BannedUsers BanUserOnRoom[]
+  MutedUsers  MuteUserOnRoom[]
 }
 
 enum AccessLevel {
@@ -91,6 +93,19 @@ model BanUserOnRoom {
   @@unique(fields: [userId, roomId], name: "userId_roomId_unique")
 }
 
+model MuteUserOnRoom {
+  user   User @relation(fields: [userId], references: [id], onDelete: Cascade)
+  userId Int
+
+  room   Room @relation(fields: [roomId], references: [id], onDelete: Cascade)
+  roomId Int
+
+  createdAt DateTime @default(now())
+  expiresAt DateTime?
+
+  @@unique(fields: [userId, roomId], name: "userId_roomId_unique")
+}
+
 model Message {
   id      Int    @id @default(autoincrement())
   content String

backend/src/app.module.ts

@@ -10,6 +10,7 @@ import { FriendRequestModule } from './friend-request/friend-request.module';
 import { HistoryModule } from './history/history.module';
 import { PrismaModule } from './prisma/prisma.module';
 import { BanModule } from './room/ban/ban.module';
+import { MuteModule } from './room/mute/mute.module';
 import { RoomModule } from './room/room.module';
 import { UserModule } from './user/user.module';
 
@@ -19,6 +20,7 @@ import { UserModule } from './user/user.module';
     PrismaModule,
     AuthModule,
     BanModule,
+    MuteModule,
     RoomModule,
     EventsModule,
     ChatModule,

backend/src/chat/chat.gateway.ts

@@ -10,6 +10,7 @@ import {
 import { Server, Socket } from 'socket.io';
 import { RoomLeftEvent } from 'src/common/events/room-left.event';
 import { ChatService } from './chat.service';
+import { MuteService } from 'src/room/mute/mute.service';
 import { CreateMessageDto } from './dto/create-message.dto';
 import { MessageEntity } from './entities/message.entity';
 
@@ -21,7 +22,10 @@ import { MessageEntity } from './entities/message.entity';
   cookie: true,
 })
 export class ChatGateway {
-  constructor(private readonly chatService: ChatService) {}
+  constructor(
+    private readonly chatService: ChatService,
+    private readonly muteService: MuteService,
+  ) {}
 
   @WebSocketServer()
   server: Server;
@@ -46,6 +50,11 @@ export class ChatGateway {
       return;
     }
 
+    const MutedUsers = await this.muteService.findAll(data.roomId);
+    if (MutedUsers.some((user) => user.id === data.userId)) {
+      return;
+    }
+
     // Save message to the database
     await this.chatService.createMessage(data);
 

backend/src/chat/chat.module.ts

@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { AuthModule } from 'src/auth/auth.module';
+import { MuteService } from 'src/room/mute/mute.service';
 import { PrismaModule } from 'src/prisma/prisma.module';
 import { UserService } from '../user/user.service';
 import { ChatController } from './chat.controller';
@@ -8,7 +9,7 @@ import { ChatService } from './chat.service';
 
 @Module({
   controllers: [ChatController],
-  providers: [ChatGateway, ChatService, UserService],
+  providers: [ChatGateway, ChatService, MuteService, UserService],
   imports: [PrismaModule, AuthModule],
 })
 export class ChatModule {}

backend/src/room/mute/dto/create-mute.dto.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNumber, IsOptional } from 'class-validator';
+
+export class CreateMuteDto {
+  @IsNumber()
+  @IsOptional()
+  @ApiProperty({ required: false })
+  duration: number;
+}

backend/src/room/mute/dto/update-mute.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateMuteDto } from './create-mute.dto';
+
+export class UpdateMuteDto extends PartialType(CreateMuteDto) {}

backend/src/room/mute/entities/mute.entity.ts

@@ -0,0 +1 @@
+export class Mute {}

backend/src/room/mute/mute.controller.spec.ts

@@ -0,0 +1,21 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PrismaService } from 'src/prisma/prisma.service';
+import { MuteController } from './mute.controller';
+import { MuteService } from './mute.service';
+
+describe('MuteController', () => {
+  let controller: MuteController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [MuteController],
+      providers: [MuteService, PrismaService],
+    }).compile();
+
+    controller = module.get<MuteController>(MuteController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/room/mute/mute.controller.ts

@@ -0,0 +1,48 @@
+import {
+  Controller,
+  Get,
+  Put,
+  Body,
+  Delete,
+  Param,
+  ParseIntPipe,
+  UseGuards,
+} from '@nestjs/common';
+import { CreateMuteDto } from './dto/create-mute.dto';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { JwtAuthGuard } from 'src/auth/jwt-auth.guard';
+import { AdminGuard } from '../guards/admin.guard';
+import { MuteService } from './mute.service';
+
+@ApiTags('mute')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('room/:roomId/mutes')
+export class MuteController {
+  constructor(private readonly muteService: MuteService) {}
+
+  @Put(':userId')
+  @UseGuards(AdminGuard)
+  create(
+    @Param('roomId', ParseIntPipe) roomId: number,
+    @Param('userId', ParseIntPipe) userId: number,
+    @Body() createMuteDto: CreateMuteDto,
+  ) {
+    return this.muteService.create(roomId, userId, createMuteDto);
+  }
+
+  @Get()
+  @UseGuards(AdminGuard)
+  findAll(@Param('roomId', ParseIntPipe) roomId: number) {
+    return this.muteService.findAll(roomId);
+  }
+
+  @Delete(':userId')
+  @UseGuards(AdminGuard)
+  remove(
+    @Param('roomId', ParseIntPipe) roomId: number,
+    @Param('userId', ParseIntPipe) userId: number,
+  ) {
+    return this.muteService.remove(roomId, userId);
+  }
+}

backend/src/room/mute/mute.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { PrismaModule } from 'src/prisma/prisma.module';
+import { MuteService } from './mute.service';
+import { MuteController } from './mute.controller';
+
+@Module({
+  controllers: [MuteController],
+  providers: [MuteService],
+  imports: [PrismaModule],
+})
+export class MuteModule {}

backend/src/room/mute/mute.service.spec.ts

@@ -0,0 +1,19 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PrismaService } from 'src/prisma/prisma.service';
+import { MuteService } from './mute.service';
+
+describe('MuteService', () => {
+  let service: MuteService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [MuteService, PrismaService],
+    }).compile();
+
+    service = module.get<MuteService>(MuteService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/room/mute/mute.service.ts

@@ -0,0 +1,136 @@
+import {
+  BadRequestException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { CreateMuteDto } from './dto/create-mute.dto';
+import { PrismaService } from 'src/prisma/prisma.service';
+
+@Injectable()
+export class MuteService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async isExpired(roomId: number, userId: number) {
+    const now = new Date();
+    const mute = await this.prisma.muteUserOnRoom.findUnique({
+      where: {
+        userId_roomId_unique: {
+          userId,
+          roomId,
+        },
+      },
+    });
+    if (!mute) {
+      return false;
+    } else if (mute.expiresAt === null) {
+      return false;
+    } else if (mute.expiresAt <= now) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  async create(roomId: number, userId: number, createMuteDto: CreateMuteDto) {
+    await this.prisma.$transaction(async (prisma) => {
+      const room = await prisma.room.findUnique({
+        where: {
+          id: roomId,
+        },
+      });
+      if (room.accessLevel === 'DIRECT') {
+        throw new BadRequestException('Cannot mute user in DIRECT room');
+      }
+      const user = await prisma.userOnRoom.findUnique({
+        where: {
+          userId_roomId_unique: {
+            userId,
+            roomId,
+          },
+        },
+      });
+      if (!user) {
+        throw new NotFoundException('User does not exist in the room');
+      }
+      if (user.role === 'OWNER') {
+        throw new ForbiddenException('Cannot mute owner');
+      }
+      if (await this.isExpired(roomId, userId)) {
+        await this.remove(roomId, userId);
+      }
+      let expiresAt;
+      if (!createMuteDto.duration) {
+        expiresAt = null;
+      } else {
+        expiresAt = new Date();
+        expiresAt.setSeconds(expiresAt.getSeconds() + createMuteDto.duration);
+      }
+      await prisma.muteUserOnRoom.create({
+        data: {
+          userId,
+          roomId,
+          expiresAt,
+        },
+      });
+    });
+    return {
+      message: 'Mute user successfully',
+    };
+  }
+
+  async findAll(roomId: number) {
+    const now = new Date();
+    const tmp = await this.prisma.muteUserOnRoom.findMany({
+      where: {
+        roomId,
+        OR: [
+          {
+            expiresAt: {
+              gt: now,
+            },
+          },
+          {
+            expiresAt: null,
+          },
+        ],
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            avatarURL: true,
+          },
+        },
+      },
+    });
+    const users = tmp.map((item) => item.user);
+    return users;
+  }
+
+  async remove(roomId: number, userId: number) {
+    await this.prisma.$transaction(async (prisma) => {
+      const user = await prisma.muteUserOnRoom.findUnique({
+        where: {
+          userId_roomId_unique: {
+            userId,
+            roomId,
+          },
+        },
+      });
+      if (!user) {
+        throw new NotFoundException('User not found in the Mute list');
+      }
+      await prisma.muteUserOnRoom.delete({
+        where: {
+          userId_roomId_unique: {
+            userId,
+            roomId,
+          },
+        },
+      });
+      return { message: 'Unmute user successfully' };
+    });
+  }
+}