Merge pull request #271 from makeopensource/126-cateogry-score

updated category-score

Author: RA341

devU-api/src/entities/categoryScore/categoryScore.controller.ts

@@ -1,14 +1,19 @@
-import { Request, Response, NextFunction } from 'express'
+import { NextFunction, Request, Response } from 'express'
 
 import CategoryScoreService from './categoryScore.service'
 
 import { NotFound, Updated } from '../../utils/apiResponse.utils'
-
 import { serialize } from './categoryScore.serializer'
+import { CategoryScorePatch, CategoryScorePost } from 'devu-shared-modules'
 
-export async function get(req: Request, res: Response, next: NextFunction) {
+export async function listByCourse(req: Request, res: Response, next: NextFunction) {
   try {
-    const categoryScores = await CategoryScoreService.list()
+    const courseId = parseInt(req.params.courseId, 10)
+    if (isNaN(courseId)) {
+      return res.status(400).json({ message: 'Invalid course ID format' })
+    }
+
+    const categoryScores = await CategoryScoreService.listByCourse(courseId)
     const response = categoryScores.map(serialize)
 
     res.status(200).json(response)
@@ -17,24 +22,43 @@ export async function get(req: Request, res: Response, next: NextFunction) {
   }
 }
 
-export async function getByCourse(req: Request, res: Response, next: NextFunction) {
+export async function detailById(req: Request, res: Response, next: NextFunction) {
   try {
-    const courseId = parseInt(req.params.courseId)
-    const categoryScores = await CategoryScoreService.listByCourse(courseId)
-    const response = categoryScores.map(serialize)
+    const id = parseInt(req.params.id, 10)
+    if (isNaN(id)) {
+      return res.status(400).json({ message: 'Invalid category score ID format' })
+    }
+
+    const categoryScore = await CategoryScoreService.retrieve(id)
+
+    if (!categoryScore) {
+      // Use the imported NotFound response utility
+      return res.status(404).json(NotFound)
+    }
+
+    // Serialize the single entity
+    const response = serialize(categoryScore)
 
     res.status(200).json(response)
   } catch (err) {
     next(err)
   }
 }
 
-export async function detail(req: Request, res: Response, next: NextFunction) {
+export async function detailByName(req: Request, res: Response, next: NextFunction) {
   try {
-    const id = parseInt(req.params.id)
-    const categoryScore = await CategoryScoreService.retrieve(id)
+    // Category name is likely a string, no need to parse as int
+    const categoryName = req.params.categoryName
+    if (!categoryName) {
+      return res.status(400).json({ message: 'Category name parameter is required' })
+    }
+
+    // Use the retrieveByName method from the service
+    const categoryScore = await CategoryScoreService.retrieveByName(categoryName)
 
-    if (!categoryScore) return res.status(404).json(NotFound)
+    if (!categoryScore) {
+      return res.status(404).json(NotFound)
+    }
 
     const response = serialize(categoryScore)
 
@@ -44,40 +68,66 @@ export async function detail(req: Request, res: Response, next: NextFunction) {
   }
 }
 
+
 export async function post(req: Request, res: Response, next: NextFunction) {
   try {
-    const categoryScore = await CategoryScoreService.create(req.body)
-    const response = serialize(categoryScore)
+    const courseId = parseInt(req.params.courseId, 10)
+    const categoryScoreDto: CategoryScorePost = req.body
+    categoryScoreDto.courseId = courseId
 
+    const newCategoryScore = await CategoryScoreService.create(categoryScoreDto)
+
+    const response = serialize(newCategoryScore)
     res.status(201).json(response)
   } catch (err) {
     next(err)
   }
 }
 
-export async function put(req: Request, res: Response, next: NextFunction) {
+export async function update(req: Request, res: Response, next: NextFunction) {
   try {
-    req.body.id = parseInt(req.params.id)
-    const results = await CategoryScoreService.update(req.body)
+    const id = parseInt(req.params.id, 10)
+    if (isNaN(id)) {
+      return res.status(400).json({ message: 'Invalid category score ID format' })
+    }
+
+    const categoryScoreDto: CategoryScorePatch = req.body
+    const results = await CategoryScoreService.update(id, categoryScoreDto)
 
-    if (!results.affected) return res.status(404).json(NotFound)
+    if (!results.affected || results.affected === 0) {
+      return res.status(404).json(NotFound)
+    }
 
     res.status(200).json(Updated)
   } catch (err) {
     next(err)
   }
 }
+
 export async function _delete(req: Request, res: Response, next: NextFunction) {
   try {
-    const id = parseInt(req.params.id)
+    const id = parseInt(req.params.id, 10)
+    if (isNaN(id)) {
+      return res.status(400).json({ message: 'Invalid category score ID format' })
+    }
+
     const results = await CategoryScoreService._delete(id)
 
-    if (!results.affected) return res.status(404).json(NotFound)
+    if (!results.affected || results.affected === 0) {
+      return res.status(404).json(NotFound)
+    }
 
     res.status(204).send()
   } catch (err) {
     next(err)
   }
 }
 
-export default { get, getByCourse, detail, post, put, _delete }
+export default {
+  listByCourse,
+  detailById,
+  detailByName,
+  post,
+  update,
+  _delete,
+}

devU-api/src/entities/categoryScore/categoryScore.model.ts

@@ -1,40 +1,19 @@
 import {
-  PrimaryGeneratedColumn,
+  Column,
   CreateDateColumn,
-  UpdateDateColumn,
   DeleteDateColumn,
-  Column,
+  Entity,
   JoinColumn,
   ManyToOne,
-  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
 } from 'typeorm'
 
-import CategoryModel from '../category/category.model'
 import CourseModel from '../course/course.model'
-import UserModel from '../user/user.model'
+import { CategoryScoreGradeType } from 'devu-shared-modules'
 
 @Entity('category_score')
 export default class CategoryScoreModel {
-  /**
-   * @swagger
-   * tags:
-   *   - name: CategoryScores
-   *     description: Route is currently non-functional, TS2305 error (Issue #34)
-   * components:
-   *  schemas:
-   *    CategoryScore:
-   *      type: object
-   *      required: [category, courseId, userId, score]
-   *      properties:
-   *        category:
-   *          type: string
-   *        courseId:
-   *          type: integer
-   *        userId:
-   *          type: integer
-   *        score:
-   *          type: number
-   */
   @PrimaryGeneratedColumn()
   id: number
 
@@ -52,16 +31,14 @@ export default class CategoryScoreModel {
   @ManyToOne(() => CourseModel)
   courseId: number
 
-  @Column({ name: 'user_id' })
-  @JoinColumn({ name: 'user_id' })
-  @ManyToOne(() => UserModel)
-  userId: number
-
-  @Column({ name: 'category_id' })
-  @JoinColumn({ name: 'category_id' })
-  @ManyToOne(() => CategoryModel)
-  categoryId: number
+  @Column({ name: 'category_name' })
+  category: string
 
-  @Column({ name: 'score', type: 'float', nullable: true })
-  score: number
+  @Column({
+    type: 'enum',
+    enum: CategoryScoreGradeType,
+    default: CategoryScoreGradeType.AVERAGE,
+    name: 'category_scoring_type',
+  })
+  categoryScoringType: CategoryScoreGradeType
 }