Add user contoller, user module, user service, question controller, question module, and questions service

Author: wjacobw

backend/question-service/src/app.controller.spec.ts

@@ -1,10 +1,11 @@
 import { Module } from '@nestjs/common';
-import { AppController } from './app.controller';
-import { AppService } from './app.service';
+import { MongooseModule } from '@nestjs/mongoose';
+import { QuestionsModule } from './questions/questions.module';
 
 @Module({
-  imports: [],
-  controllers: [AppController],
-  providers: [AppService],
+  imports: [
+    MongooseModule.forRoot('mongodb://127.0.0.1/PeerPrep'),
+    QuestionsModule,
+  ],
 })
 export class AppModule {}

backend/question-service/src/app.controller.ts

@@ -0,0 +1,49 @@
+import {
+  IsBoolean,
+  IsNotEmpty,
+  IsOptional,
+  IsEnum,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+enum Category {
+  Algorithm = 'Algorithm',
+  DynamicProgramming = 'DynamicProgramming',
+  Array = 'Array',
+  SQL = 'SQL',
+  Heap = 'Heap',
+  Recursion = 'Recursion',
+  Graph = 'Graph',
+  Sorting = 'Sorting',
+}
+
+enum Difficulty {
+  Easy = 'easy',
+  Medium = 'medium',
+  Hard = 'hard',
+}
+
+export class CreateQuestionDto {
+  @IsNotEmpty()
+  @IsString()
+  title: string;
+
+  @IsNotEmpty()
+  @IsString()
+  description: string;
+  '';
+  @IsNotEmpty()
+  @IsEnum(Category, {
+    message:
+      'Category must be Algorithm, DynamicProgramming, Array, SQL, Heap, Recursion, Graph, Sorting',
+  })
+  category: Category;
+
+  @IsNotEmpty()
+  @IsEnum(Difficulty, {
+    message: 'Difficulty must be easy, medium, hard',
+  })
+  difficulty: Difficulty;
+}

backend/question-service/src/app.module.ts

@@ -0,0 +1,50 @@
+import {
+    IsBoolean,
+    IsNotEmpty,
+    IsOptional,
+    IsEnum,
+    IsString,
+    ValidateNested,
+  } from 'class-validator';
+  import { Type } from 'class-transformer';
+  
+  enum Category {
+    Algorithm = 'Algoritm',
+    DynamicProgramming = 'DynamicProgramming',
+    Array = 'Array',
+    SQL = 'SQL',
+    Heap = 'Heap',
+    Recursion = 'Recursion',
+    Graph = 'Graph',
+    Sorting = 'Sorting',
+  }
+  
+  enum Difficulty {
+    Easy = 'easy',
+    Medium = 'medium',
+    Hard = 'hard',
+  }
+  
+  export class UpdateQuestionDto {
+    @IsNotEmpty()
+    @IsString()
+    title: string;
+  
+    @IsNotEmpty()
+    @IsString()
+    description: string;
+  
+    @IsNotEmpty()
+    @IsEnum(Category, {
+      message:
+        'Category must be Algorithm, DynamicProgramming, Array, SQL, Heap, Recursion, Graph, Sorting',
+    })
+    category: Category;
+  
+    @IsNotEmpty()
+    @IsEnum(Difficulty, {
+      message: 'Difficulty must be easy, medium, hard',
+    })
+    difficulty: Difficulty;
+  }
+  

backend/question-service/src/app.service.ts

@@ -0,0 +1,62 @@
+import mongoose from 'mongoose';
+import {
+  Controller,
+  Post,
+  Body,
+  Get,
+  Param,
+  HttpException,
+  Patch,
+  Delete,
+} from '@nestjs/common';
+import { QuestionsService } from './questions.service';
+import { CreateQuestionDto } from '../dto/CreateQuestion.dto';
+import { UpdateQuestionDto } from '../dto/UpdateQuestion.dto';
+
+@Controller('questions')
+export class QuestionsController {
+  constructor(private questionsService: QuestionsService) {}
+
+  @Post()
+  createQuestion(@Body() CreateQuestionDto: CreateQuestionDto) {
+    return this.questionsService.createQuestion(CreateQuestionDto);
+  }
+
+  @Get()
+  getQuestions() {
+    return this.questionsService.getQuestions();
+  }
+
+  @Get(':id')
+  async getQuestionsById(@Param('id') id: string) {
+    const isValid = mongoose.Types.ObjectId.isValid(id);
+    if (!isValid) throw new HttpException('Question not found', 404);
+    const findQuestion = await this.questionsService.getQuestionsById(id);
+    if (!findQuestion) throw new HttpException('Question not found', 404);
+    return findQuestion;
+  }
+
+  @Patch(':id')
+  async updateQuestion(
+    @Param('id') id: string,
+    @Body() UpdateQuestionDto: UpdateQuestionDto,
+  ) {
+    const isValid = mongoose.Types.ObjectId.isValid(id);
+    if (!isValid) throw new HttpException('Invalid ID', 400);
+    const updateQuestion = await this.questionsService.updateQuestion(
+      id,
+      UpdateQuestionDto,
+    );
+    if (!updateQuestion) throw new HttpException('Question Not Found', 404);
+    return updateQuestion;
+  }
+
+  @Delete(':id')
+  async deleteQuestion(@Param('id') id: string) {
+    const isValid = mongoose.Types.ObjectId.isValid(id);
+    if (!isValid) throw new HttpException('Invalid ID', 400);
+    const deletedUser = await this.questionsService.deleteQuestion(id);
+    if (!deletedUser) throw new HttpException('Question not Found', 404);
+    return;
+  }
+}

backend/question-service/src/dto/CreateQuestion.dto.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Question, QuestionSchema } from '../schemas/Question.schema';
+import { QuestionsService } from './questions.service';
+import { QuestionsController } from './questions.controller';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      {
+        name: Question.name,
+        schema: QuestionSchema,
+      },
+    ]),
+  ],
+  providers: [QuestionsService],
+  controllers: [QuestionsController],
+})
+export class QuestionsModule {}

backend/question-service/src/dto/UpdateQuestion.dto.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common';
+import { CreateQuestionDto } from '../dto/CreateQuestion.dto';
+import { Question } from '../schemas/Question.schema';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { UpdateQuestionDto } from '../dto/UpdateQuestion.dto';
+
+@Injectable()
+export class QuestionsService {
+  constructor(
+    @InjectModel(Question.name) private questionModel: Model<Question>,
+  ) {}
+
+  async createQuestion(createQuestionDto: CreateQuestionDto) {
+    const newQuestion = new this.questionModel(createQuestionDto);
+    return newQuestion.save();
+  }
+
+  getQuestions() {
+    return this.questionModel.find();
+  }
+
+  getQuestionsById(id: string) {
+    return this.questionModel.findById(id);
+  }
+
+  updateQuestion(id: string, updateUserDto: UpdateQuestionDto) {
+    return this.questionModel.findByIdAndUpdate(id, updateUserDto, {
+      new: true,
+    });
+  }
+
+  deleteQuestion(id: string) {
+    return this.questionModel.findByIdAndDelete(id);
+  }
+}

backend/question-service/src/questions/questions.controller.ts

@@ -0,0 +1,22 @@
+import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';
+import mongoose from 'mongoose';
+
+@Schema()
+export class Question {
+  @Prop({ unique: true })
+  id: string;
+
+  @Prop({ unique: true, required: true })
+  title: string;
+
+  @Prop({ required: true })
+  description: string;
+
+  @Prop({ required: true })
+  category: string;
+
+  @Prop({ required: true })
+  difficulty: string;
+}
+
+export const QuestionSchema = SchemaFactory.createForClass(Question)