feat(be): implement admin announcement module

backend/apps/admin/src/announcement/announcement.resolver.spec.ts

@@ -0,0 +1,23 @@
+import { Test, type TestingModule } from '@nestjs/testing'
+import { expect } from 'chai'
+import { AnnouncementResolver } from './announcement.resolver'
+import { AnnouncementService } from './announcement.service'
+
+describe('AnnouncementResolver', () => {
+  let resolver: AnnouncementResolver
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AnnouncementResolver,
+        { provide: AnnouncementService, useValue: {} }
+      ]
+    }).compile()
+
+    resolver = module.get<AnnouncementResolver>(AnnouncementResolver)
+  })
+
+  it('shoulld be defined', () => {
+    expect(resolver).to.be.ok
+  })
+})

backend/apps/admin/src/announcement/announcement.resolver.ts

@@ -1,44 +1,85 @@
+import { InternalServerErrorException, Logger } from '@nestjs/common'
 import { Resolver, Query, Mutation, Args, Int } from '@nestjs/graphql'
-import { Announcement } from '@generated'
+import {
+  DuplicateFoundException,
+  EntityNotExistException
+} from '@libs/exception'
+import { Announcement } from '@admin/@generated'
 import { AnnouncementService } from './announcement.service'
-import { CreateAnnouncementInput } from './dto/create-announcement.input'
-import { UpdateAnnouncementInput } from './dto/update-announcement.input'
+import { AnnouncementInput } from './dto/announcement.input'
 
 @Resolver(() => Announcement)
 export class AnnouncementResolver {
+  private readonly logger = new Logger(AnnouncementResolver.name)
   constructor(private readonly announcementService: AnnouncementService) {}
 
   @Mutation(() => Announcement)
-  createAnnouncement(
+  async createAnnouncement(
     @Args('createAnnouncementInput')
-    createAnnouncementInput: CreateAnnouncementInput
+    announcementInput: AnnouncementInput
   ) {
-    return this.announcementService.create(createAnnouncementInput)
+    try {
+      return await this.announcementService.create(announcementInput)
+    } catch (error) {
+      if (error instanceof DuplicateFoundException || EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
-  @Query(() => [Announcement], { name: 'announcement' })
-  findAll() {
-    return this.announcementService.findAll()
+  @Query(() => [Announcement], { name: 'getAnnouncementsByProblemId' })
+  async getAnnouncementsByProblemId(
+    @Args('problemId', { type: () => Int }) problemId: number
+  ) {
+    try {
+      return await this.announcementService.findAll(problemId)
+    } catch (error) {
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
-  @Query(() => Announcement, { name: 'announcement' })
-  findOne(@Args('id', { type: () => Int }) id: number) {
-    return this.announcementService.findOne(id)
+  @Query(() => Announcement, { name: 'getAnnouncement' })
+  async getAnnouncement(@Args('id', { type: () => Int }) id: number) {
+    try {
+      return await this.announcementService.findOne(id)
+    } catch (error) {
+      if (error instanceof EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
   @Mutation(() => Announcement)
-  updateAnnouncement(
-    @Args('updateAnnouncementInput')
-    updateAnnouncementInput: UpdateAnnouncementInput
+  async updateAnnouncement(
+    @Args('id', { type: () => Int }) id: number,
+    @Args('announcementInput') announcementInput: AnnouncementInput
   ) {
-    return this.announcementService.update(
-      updateAnnouncementInput.id,
-      updateAnnouncementInput
-    )
+    try {
+      return await this.announcementService.update(id, announcementInput)
+    } catch (error) {
+      if (error instanceof EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
   @Mutation(() => Announcement)
-  removeAnnouncement(@Args('id', { type: () => Int }) id: number) {
-    return this.announcementService.remove(id)
+  async removeAnnouncement(@Args('id', { type: () => Int }) id: number) {
+    try {
+      return await this.announcementService.delete(id)
+    } catch (error) {
+      if (error instanceof EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 }

backend/apps/admin/src/announcement/announcement.service.spec.ts

@@ -0,0 +1,138 @@
+import { Test, type TestingModule } from '@nestjs/testing'
+import { faker } from '@faker-js/faker'
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library'
+import { expect } from 'chai'
+import { stub } from 'sinon'
+import {
+  DuplicateFoundException,
+  EntityNotExistException
+} from '@libs/exception'
+import { PrismaService } from '@libs/prisma'
+import { AnnouncementService } from './announcement.service'
+
+const problemId = faker.number.int()
+const id = faker.number.int()
+const announcementInput = {
+  problemId,
+  content: faker.string.sample()
+}
+
+const announcement = {
+  ...announcementInput,
+  id
+}
+
+const problem = {
+  problemId
+}
+
+const db = {
+  announcement: {
+    findFirst: stub(),
+    findMany: stub().resolves([announcement]),
+    update: stub(),
+    delete: stub(),
+    create: stub().resolves(announcement)
+  },
+  problem: {
+    findFirst: stub()
+  }
+}
+
+const PrismaErrorInstance = new PrismaClientKnownRequestError('error', {
+  code: '4xx',
+  clientVersion: 'x.x.x'
+})
+
+describe('AnnouncementService', () => {
+  let service: AnnouncementService
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AnnouncementService, { provide: PrismaService, useValue: db }]
+    }).compile()
+
+    service = module.get<AnnouncementService>(AnnouncementService)
+  })
+
+  it('should be defined', () => {
+    expect(service).to.be.ok
+  })
+
+  describe('create', () => {
+    it('should return created announcement', async () => {
+      db.announcement.findFirst.resolves(null)
+      db.problem.findFirst.resolves(problem)
+
+      const res = await service.create(announcementInput)
+      expect(res).to.deep.equal(announcement)
+    })
+
+    it('should throw error when given announcement already exists', async () => {
+      db.announcement.findFirst.resolves(announcement)
+
+      await expect(service.create(announcementInput)).to.be.rejectedWith(
+        DuplicateFoundException
+      )
+    })
+
+    it('should throw error when given problemId is invalid', async () => {
+      db.announcement.findFirst.resolves(null)
+      db.problem.findFirst.resolves(null)
+
+      await expect(service.create(announcementInput)).to.be.rejectedWith(
+        EntityNotExistException
+      )
+    })
+  })
+
+  describe('findAll', () => {
+    it('should return all announcements', async () => {
+      db.announcement.findMany()
+      const res = await service.findAll(problemId)
+      expect(res).to.deep.equal([announcement])
+    })
+  })
+
+  describe('findOne', () => {
+    it('should throw error when given id is invalid', async () => {
+      db.announcement.findFirst.resolves(null)
+      await expect(service.findOne(id)).to.be.rejectedWith(
+        EntityNotExistException
+      )
+    })
+    it('should return an announcement', async () => {
+      db.announcement.findFirst.resolves(announcement)
+      const res = await service.findOne(id)
+      expect(res).to.deep.equal(announcement)
+    })
+  })
+
+  describe('update', () => {
+    it('should return updated announcement', async () => {
+      db.announcement.update.resolves(announcement)
+      const res = await service.update(id, announcementInput)
+      expect(res).to.deep.equal(announcement)
+    })
+    it('should throw error when given id is invalid', async () => {
+      db.announcement.update.rejects(PrismaErrorInstance)
+      await expect(service.update(id, announcementInput)).to.be.rejectedWith(
+        EntityNotExistException
+      )
+    })
+  })
+
+  describe('delete', () => {
+    it('should return deleted announcement', async () => {
+      db.announcement.delete.resolves(announcement)
+      const res = await service.delete(id)
+      expect(res).to.deep.equal(announcement)
+    })
+    it('should throw error when given id is invalid', async () => {
+      db.announcement.delete.rejects(PrismaErrorInstance)
+      await expect(service.delete(id)).to.be.rejectedWith(
+        EntityNotExistException
+      )
+    })
+  })
+})

backend/apps/admin/src/announcement/announcement.service.ts

@@ -1,26 +1,94 @@
-import { Injectable } from '@nestjs/common'
-import type { CreateAnnouncementInput } from './dto/create-announcement.input'
-import type { UpdateAnnouncementInput } from './dto/update-announcement.input'
+import { Injectable, Logger } from '@nestjs/common'
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library'
+import {
+  EntityNotExistException,
+  DuplicateFoundException
+} from '@libs/exception'
+import { PrismaService } from '@libs/prisma'
+import type { AnnouncementInput } from './dto/announcement.input'
 
 @Injectable()
 export class AnnouncementService {
-  create(createAnnouncementInput: CreateAnnouncementInput) {
-    return createAnnouncementInput
+  private readonly logger = new Logger(AnnouncementService.name)
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async create(
+    announcementInput: AnnouncementInput
+  ): Promise<AnnouncementInput> {
+    const announcement = await this.prisma.announcement.findFirst({
+      where: {
+        problemId: announcementInput.problemId,
+        content: announcementInput.content
+      }
+    })
+    if (announcement) throw new DuplicateFoundException('announcement')
+
+    await this.prisma.problem
+      .findFirstOrThrow({
+        where: {
+          id: announcementInput.problemId
+        }
+      })
+      .catch((error) => {
+        if (error.name == 'NotFoundError') {
+          throw new EntityNotExistException('prolem')
+        }
+      })
+
+    return await this.prisma.announcement.create({
+      data: {
+        problemId: announcementInput.problemId,
+        content: announcementInput.content
+      }
+    })
   }
 
-  findAll() {
-    return `This action returns all announcement`
+  async findAll(problemId: number) {
+    return await this.prisma.announcement.findMany({
+      where: {
+        problemId
+      }
+    })
   }
 
-  findOne(id: number) {
-    return `This action returns a #${id} announcement`
+  async findOne(id: number) {
+    const announcement = await this.prisma.announcement
+      .findFirstOrThrow({
+        where: {
+          id
+        }
+      })
+      .catch((error) => {
+        if (error.name == 'NotFoundError') {
+          throw new EntityNotExistException('announcement')
+        }
+      })
+    return announcement
   }
 
-  update(id: number, updateAnnouncementInput: UpdateAnnouncementInput) {
-    return updateAnnouncementInput
+  async update(id: number, announcementInput: AnnouncementInput) {
+    try {
+      return await this.prisma.announcement.update({
+        where: { id },
+        data: announcementInput
+      })
+    } catch (error) {
+      if (error instanceof PrismaClientKnownRequestError) {
+        throw new EntityNotExistException('announcement')
+      }
+    }
   }
 
-  remove(id: number) {
-    return `This action removes a #${id} announcement`
+  async delete(id: number) {
+    try {
+      return await this.prisma.announcement.delete({
+        where: { id }
+      })
+    } catch (error) {
+      if (error instanceof PrismaClientKnownRequestError) {
+        throw new EntityNotExistException('announcement')
+      }
+    }
   }
 }

backend/apps/admin/src/announcement/dto/announcement.input.ts

@@ -0,0 +1,10 @@
+import { InputType, Int, Field } from '@nestjs/graphql'
+
+@InputType()
+export class AnnouncementInput {
+  @Field(() => Int)
+  problemId: number
+
+  @Field(() => String)
+  content: string
+}