Add Create question route and service (#16)

* feat: add create grading question proto and types

* feat: add create workspace question proto and types

* feat: add create grading question repository

* feat: add create grading testcase repository

* feat: add create grading question route and service

* feat: create update workspace question repo

* feat: add create workspace question service and route

* feat: add guard for workspace owner only

* feat: add gateway route and service for create question

* feat: add header validation in create question route

* feat: add response type of create question

packages/proto/grading/entity.proto

@@ -27,6 +27,15 @@ message QuestionSummary {
   string status = 3;
 }
 
+message CreateGradingQuestion {
+  int32 questionId = 1;
+  int32 workspaceId = 2;
+  int32 score = 3;
+  string name = 4;
+  double memoryLimit = 5;
+  double timeLimit  = 6;
+}
+
 // TODO: hardcoded for BMH2023
 message Rank {
   string userId = 1;

packages/proto/grading/message.proto

@@ -49,6 +49,14 @@ message GetQuestionSummaryByIdsResponse {
   repeated QuestionSummary questionSummaries = 1;
 }
 
+message CreateGradingQuestionRequest {
+  CreateGradingQuestion question = 1;
+}
+
+message CreateGradingQuestionResponse {
+  CreateGradingQuestion question = 1;
+}
+
 // TODO: hardcoded for BMH2023
 message GetRankingResponse {
   repeated Rank ranks = 1;

packages/proto/grading/service.proto

@@ -10,6 +10,7 @@ service GradingService {
   rpc Submit(SubmitRequest) returns (SubmitResponse);
   rpc Grade(GradeRequest) returns (GradeResponse);
   rpc GetQuestionSummaryByIds(GetQuestionSummaryByIdsRequest) returns (GetQuestionSummaryByIdsResponse);
+  rpc CreateGradingQuestion(CreateGradingQuestionRequest) returns (CreateGradingQuestionResponse);
   // TODO: hardcoded for BMH2023
   rpc GetRanking(Empty) returns (GetRankingResponse);
 }

packages/proto/workspace/entity.proto

@@ -31,3 +31,13 @@ message Question {
   int32 workspaceId = 8;
   uint64 createdAt = 9;
 }
+
+// Omit<Question, 'id' | 'detailPath' | 'createdAt'>,
+message CreateWorkspaceQuestion {
+  string name = 1;
+  string description = 2;
+  double memoryLimit = 3;
+  double timeLimit  = 4;
+  string level = 5;
+  int32 workspaceId = 6;
+}

packages/proto/workspace/message.proto

@@ -43,3 +43,11 @@ message GetQuestionByIdRequest {
 message GetQuestionByIdResponse {
   Question question = 1;
 }
+
+message CreateWorkspaceQuestionRequest {
+  CreateWorkspaceQuestion question = 1;
+}
+
+message CreateWorkspaceQuestionResponse {
+  Question question = 1;
+}

packages/proto/workspace/service.proto

@@ -11,4 +11,5 @@ service WorkspaceService {
   rpc GetWorkspaceById(GetWorkspaceByIdRequest) returns (GetWorkspaceByIdResponse);
   rpc GetQuestionsByWorkspaceId(GetQuestionsByWorkspaceIdRequest) returns (GetQuestionsByWorkspaceIdResponse);
   rpc GetQuestionById(GetQuestionByIdRequest) returns (GetQuestionByIdResponse);
+  rpc CreateWorkspaceQuestion(CreateWorkspaceQuestionRequest) returns (CreateWorkspaceQuestionResponse);
 }

packages/shared-external/src/workspace/index.ts

@@ -13,3 +13,5 @@ export type PublicQuestion = Omit<Question, 'workspaceId'> & {
   lastSubmitted: number,
   status: QuestionStatus,
 };
+
+export type PublicCreatedQuestion = Question & { score: number };

packages/shared-internal/src/grading/message.ts

@@ -56,6 +56,18 @@ export type GetQuestionSummaryByIdsResponse = {
   questionSummaries: QuestionSummary[],
 };
 
+export type CreateGradingQuestionRequest = {
+  question: {
+    questionId: number,
+    workspaceId: number,
+    score: number,
+    timeLimit: number,
+    memoryLimit: number,
+  }
+};
+
+export type CreateGradingQuestionResponse = CreateGradingQuestionRequest;
+
 // TODO: hardcoded for BMH2023
 export type GetRankingResponse = {
   ranks: Rank[],

packages/shared-internal/src/workspace/message.ts

@@ -1,4 +1,6 @@
-import { WorkspaceWithParticipants, Workspace, Question } from './entity';
+import {
+  WorkspaceWithParticipants, Workspace, Question,
+} from './entity';
 
 export type ValidateUserInWorkspaceRequest = {
   userId: string,
@@ -41,3 +43,11 @@ export type GetQuestionByIdRequest = {
 export type GetQuestionByIdResponse = {
   question: Question,
 };
+
+export type CreateWorkspaceQuestionRequest = {
+  question: Omit<Question, 'id' | 'detailPath' | 'createdAt'>,
+};
+
+export type CreateWorkspaceQuestionResponse = {
+  question: Question,
+};

services/gateway/src/controllers/WorkspaceController.ts

@@ -1,12 +1,13 @@
 import {
   Controller, Inject, Get,
-  UseGuards, Param,
+  UseGuards, Param, Post,
 } from '@nestjs/common';
 import { ClientGrpc } from '@nestjs/microservices';
 import { firstValueFrom, forkJoin, map } from 'rxjs';
 import {
   PublicUser, PublicWorkspaceWithParticipants, PublicQuestion,
   PublicWorkspace,
+  PublicCreatedQuestion,
 } from '@codern/external';
 import { WorkspaceService } from '@/services/WorkspaceService';
 import { User } from '@/utils/decorators/AuthDecorator';
@@ -18,6 +19,9 @@ import {
   workspaceWithParticipants,
 } from '@/utils/Serializer';
 import { GradingService } from '@/services/GradingService';
+import { CreateQuestionDto } from '@/utils/dtos/QuestionDtos';
+import { RequestHeader } from '@/utils/decorators/HeaderDecorator';
+import { WorkspaceOwnerGuard } from '@/utils/guards/WorkspaceOwnerGuard';
 
 @Controller('/workspaces')
 export class WorkspaceController {
@@ -112,4 +116,45 @@ export class WorkspaceController {
     return publicQuestions([question], questionSummaries)[0];
   }
 
+  @Post('/:workspaceId/questions')
+  @UseGuards(AuthGuard, WorkspaceOwnerGuard)
+  public async createQuestion(
+    @Param('workspaceId') workspaceId: number,
+    @RequestHeader(CreateQuestionDto) headers: CreateQuestionDto,
+  ): Promise<PublicCreatedQuestion> {
+    const {
+      name, description, timeLimit, memoryLimit, level, score,
+    } = headers;
+
+    const { question: createdWorkspaceQuestion } = await firstValueFrom(
+      this.workspaceService.createWorkspaceQuestion({
+        question: {
+          workspaceId,
+          name,
+          description,
+          timeLimit,
+          memoryLimit,
+          level,
+        },
+      }),
+    );
+
+    const { question: createdGradingQuestion } = await firstValueFrom(
+      this.gradingService.createGradingQuestion({
+        question: {
+          questionId: createdWorkspaceQuestion.id,
+          workspaceId,
+          timeLimit,
+          memoryLimit,
+          score,
+        },
+      }),
+    );
+
+    return {
+      ...createdWorkspaceQuestion,
+      score: createdGradingQuestion.score,
+    };
+  }
+
 }

services/gateway/src/services/GradingService.ts

@@ -1,4 +1,6 @@
 import {
+  CreateGradingQuestionRequest,
+  CreateGradingQuestionResponse,
   GetQuestionSummaryByIdsRequest, GetQuestionSummaryByIdsResponse,
   GetRankingResponse,
   GetSubmissionsByQuestionIdRequest, GetSubmissionsByQuestionIdResponse, GradeRequest,
@@ -25,4 +27,8 @@ export interface GradingService {
 
   getRanking(any: unknown): Observable<GetRankingResponse>;
 
+  createGradingQuestion(
+    data: CreateGradingQuestionRequest,
+  ): Observable<CreateGradingQuestionResponse>;
+
 }

services/gateway/src/services/WorkspaceService.ts

@@ -1,4 +1,6 @@
 import {
+  CreateWorkspaceQuestionRequest,
+  CreateWorkspaceQuestionResponse,
   GetAllWorkspacesByUserIdRequest, GetAllWorkspacesByUserIdResponse, GetQuestionByIdRequest,
   GetQuestionByIdResponse, GetQuestionsByWorkspaceIdRequest, GetQuestionsByWorkspaceIdResponse,
   GetWorkspaceByIdRequest, GetWorkspaceByIdResponse, ValidateQuestionInWorkspaceRequest,
@@ -24,4 +26,8 @@ export interface WorkspaceService {
 
   getQuestionById(data: GetQuestionByIdRequest): Observable<GetQuestionByIdResponse>;
 
+  createWorkspaceQuestion(
+    data: CreateWorkspaceQuestionRequest
+  ): Observable<CreateWorkspaceQuestionResponse>;
+
 }

services/gateway/src/utils/decorators/HeaderDecorator.ts

@@ -0,0 +1,18 @@
+import { BadRequestException, createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+
+export const RequestHeader = createParamDecorator(
+  async (value: any, ctx: ExecutionContext) => {
+    const { headers } = ctx.switchToHttp().getRequest();
+
+    const dto = plainToInstance(value, headers, { excludeExtraneousValues: true });
+
+    const errors = await validate(dto);
+    if (errors.length > 0) {
+      throw new BadRequestException('Invalid request headers');
+    }
+
+    return dto;
+  },
+);

services/gateway/src/utils/dtos/QuestionDtos.ts

@@ -0,0 +1,43 @@
+import { QuestionLevel } from '@codern/internal';
+import { Expose, Transform } from 'class-transformer';
+import {
+  IsDefined, IsEnum, IsInt, IsString,
+} from 'class-validator';
+
+export class CreateQuestionDto {
+
+  @IsString()
+  @IsDefined()
+  @Expose({ name: 'question-name' })
+  name!: string;
+
+  @IsString()
+  @IsDefined()
+  @Expose({ name: 'question-description' })
+  description!: string;
+
+  @Transform(({ value }) => Number.parseInt(value, 10))
+  @IsInt()
+  @IsDefined()
+  @Expose({ name: 'question-memory-limit' })
+  memoryLimit!: number;
+
+  @Transform(({ value }) => Number.parseInt(value, 10))
+  @IsInt({ message: 'invalid request header `question-time-limit`' })
+  @IsDefined()
+  @Expose({ name: 'question-time-limit' })
+  timeLimit!: number;
+
+  @Transform(({ value }) => String(value).toUpperCase())
+  @IsEnum(QuestionLevel)
+  @IsDefined()
+  @Expose({ name: 'question-level' })
+  level!: QuestionLevel;
+
+  @Transform(({ value }) => Number.parseInt(value, 10))
+  @IsInt()
+  @IsDefined()
+  @Expose({ name: 'question-score' })
+  score!: number;
+
+}

services/gateway/src/utils/guards/WorkspaceOwnerGuard.ts

@@ -0,0 +1,37 @@
+import {
+  BadRequestException,
+  CanActivate, ExecutionContext, Inject, Injectable,
+} from '@nestjs/common';
+import { ClientGrpc } from '@nestjs/microservices';
+import { FastifyRequest } from 'fastify';
+import { firstValueFrom } from 'rxjs';
+import { WorkspaceService } from '@/services/WorkspaceService';
+
+type WorkspaceGuardParams = {
+  workspaceId: string | undefined,
+  questionId: string | undefined,
+};
+
+@Injectable()
+export class WorkspaceOwnerGuard implements CanActivate {
+
+  private readonly workspaceService: WorkspaceService;
+
+  public constructor(@Inject('WORKSPACE_PACKAGE') client: ClientGrpc) {
+    this.workspaceService = client.getService<WorkspaceService>('WorkspaceService');
+  }
+
+  public async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<FastifyRequest>();
+
+    const { workspaceId } = request.params as WorkspaceGuardParams;
+    if (!workspaceId) throw new BadRequestException();
+
+    const { workspace } = await firstValueFrom(
+      this.workspaceService.getWorkspaceById({ workspaceId: Number(workspaceId) }),
+    );
+
+    return workspace.ownerId === request.user.id;
+  }
+
+}

services/grading/src/controllers/GradingController.ts

@@ -1,6 +1,8 @@
 import { Controller } from '@nestjs/common';
 import { EventPattern, GrpcMethod } from '@nestjs/microservices';
 import {
+  CreateGradingQuestionRequest,
+  CreateGradingQuestionResponse,
   GetQuestionSummaryByIdsRequest,
   GetQuestionSummaryByIdsResponse,
   GetRankingResponse,
@@ -56,6 +58,14 @@ export class GradingController {
     return { submissions };
   }
 
+  @GrpcMethod('GradingService')
+  public async createGradingQuestion(
+    data: CreateGradingQuestionRequest,
+  ): Promise<CreateGradingQuestionResponse> {
+    const question = await this.gradingService.createGradingQuestion(data.question);
+    return { question };
+  }
+
   // TODO: hardcoded for BMH2023
   @GrpcMethod('GradingService')
   public async getRanking(): Promise<GetRankingResponse> {

services/grading/src/modules/GradingModule.ts

@@ -9,6 +9,7 @@ import { GradingService } from '@/services/GradingService';
 import { QueueSerivce } from '@/services/QueueService';
 import { TestcaseRepository } from '@/repositories/TestcaseRepository';
 import { ResultRepository } from '@/repositories/ResultRepository';
+import { QuestionRepository } from '@/repositories/QuestionRepository';
 
 @Module({
   imports: [
@@ -44,6 +45,7 @@ import { ResultRepository } from '@/repositories/ResultRepository';
     ResultRepository,
     SubmissionRepository,
     TestcaseRepository,
+    QuestionRepository,
 
     QueueSerivce,
     GradingService,

services/grading/src/repositories/QuestionRepository.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma, Question } from '@prisma/client';
+import { PrismaService } from '@/services/PrismaService';
+
+@Injectable()
+export class QuestionRepository {
+
+  private readonly prismaService: PrismaService;
+
+  public constructor(prismaService: PrismaService) {
+    this.prismaService = prismaService;
+  }
+
+  public async createQuestion(question: Prisma.QuestionCreateInput): Promise<Question> {
+    const createdQuestion = await this.prismaService.question.create({ data: question });
+
+    return createdQuestion;
+  }
+
+}

services/grading/src/repositories/TestcaseRepository.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { Testcase } from '@prisma/client';
+import { Prisma, Testcase } from '@prisma/client';
 import { PrismaService } from '@/services/PrismaService';
 
 @Injectable()
@@ -15,4 +15,8 @@ export class TestcaseRepository {
     return this.prismaService.testcase.findMany({ where: { questionId } });
   }
 
+  public createTestcaseByQuestionId(testcase: Prisma.TestcaseCreateInput): Promise<Testcase> {
+    return this.prismaService.testcase.create({ data: testcase });
+  }
+
 }