Merge pull request #215 from makeopensource/67-bug-fixes

67 bug fixes

Author: RA341

devU-api/package.json

@@ -3,7 +3,8 @@
   "version": "1.0.0",
   "description": "DevU API",
   "scripts": {
-    "start": "npm run migrate && ts-node-dev src/index.ts",
+    "start": "npm run migrate && ts-node src/index.ts",
+    "dev": "npm run migrate && ts-node-dev src/index.ts",
     "migrate": "npm run typeorm -- migration:run -d src/database.ts",
     "create-migrate": "npx typeorm-ts-node-commonjs migration:generate -d src/database.ts",
     "update-shared": "cd ../devU-shared && npm run build-local && cd ../devU-api && npm i",

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

@@ -30,10 +30,12 @@ export async function detail(req: Request, res: Response, next: NextFunction) {
   }
 }
 
-export async function getObjectByAssignment(req: Request, res: Response, next: NextFunction) {
+export async function getAllByAssignment(req: Request, res: Response, next: NextFunction) {
   try {
     const assignmentId = parseInt(req.params.id)
-    const containerAutoGrader = await ContainerAutoGraderService.getGraderObjectByAssignmentId(assignmentId)
+    if (!assignmentId) return res.status(404).json({ message: 'invalid assignment ID' })
+
+    const containerAutoGrader = await ContainerAutoGraderService.getAllGradersByAssignment(assignmentId)
 
     res.status(200).json(containerAutoGrader.map(serialize))
   } catch (err) {
@@ -110,5 +112,5 @@ export default {
   post,
   put,
   _delete,
-  getObjectByAssignment,
+  getAllByAssignment,
 }

devU-api/src/entities/containerAutoGrader/containerAutoGrader.router.ts

@@ -10,19 +10,6 @@ import ContainerAutoGraderController from './containerAutoGrader.controller'
 const Router = express.Router({ mergeParams: true })
 const upload = multer()
 
-/**
- * @swagger
- * /course/:courseId/assignment/:assignmentId/container-auto-graders:
- *   get:
- *     summary: Retrieve a list of all container auto graders
- *     tags:
- *       - ContainerAutoGraders
- *     responses:
- *       '200':
- *         description: OK
- */
-Router.get('/', isAuthorized('assignmentViewAll'), ContainerAutoGraderController.get)
-
 /**
  * @swagger
  * /course/:courseId/assignment/:assignmentId/container-auto-graders/{id}:
@@ -59,7 +46,7 @@ Router.get('/:id', isAuthorized('assignmentViewAll'), asInt(), ContainerAutoGrad
  *         schema:
  *           type: integer
  */
-Router.get('/assignment/:id', asInt(), ContainerAutoGraderController.getObjectByAssignment)
+Router.get('/assignment/:id', asInt(), ContainerAutoGraderController.getAllByAssignment)
 
 /**
  * @swagger

devU-api/src/entities/containerAutoGrader/containerAutoGrader.service.ts

@@ -6,7 +6,7 @@ import { ContainerAutoGrader, FileUpload } from 'devu-shared-modules'
 import ContainerAutoGraderModel from './containerAutoGrader.model'
 import FileModel from '../../fileUpload/fileUpload.model'
 
-import { uploadFile, downloadFile } from '../../fileStorage'
+import { downloadFile, uploadFile } from '../../fileStorage'
 import { generateFilename } from '../../utils/fileUpload.utils'
 
 const connect = () => dataSource.getRepository(ContainerAutoGraderModel)
@@ -105,14 +105,11 @@ export async function list() {
   return await connect().findBy({ deletedAt: IsNull() })
 }
 
-//The grader has not changed to the new function, so the fake function keep here for now to avoid error
-//But need to be deleted when the grader entity changed to the getGraderByAssignmentId
-export async function getGraderObjectByAssignmentId(assignmentId: number) {
-  if (!assignmentId) throw new Error('Missing AssignmentId')
+export async function getAllGradersByAssignment(assignmentId: number) {
   return await connect().findBy({ assignmentId: assignmentId, deletedAt: IsNull() })
 }
 
-export async function getGraderByAssignmentId(assignmentId: number) {
+export async function loadGrader(assignmentId: number) {
   const containerAutoGraders = await connect().findOneBy({ assignmentId: assignmentId, deletedAt: IsNull() })
   if (!containerAutoGraders) return { graderData: null, makefileData: null, autogradingImage: null, timeout: null }
 
@@ -135,6 +132,6 @@ export default {
   update,
   _delete,
   list,
-  getGraderByAssignmentId,
-  getGraderObjectByAssignmentId,
+  loadGrader,
+  getAllGradersByAssignment,
 }

devU-api/src/entities/grader/grader.service.ts

@@ -108,7 +108,7 @@ async function runContainerAutograders(filepaths: string[], submission: Submissi
   let jobResponse = null
 
   const { graderData, makefileData, autogradingImage, timeout } =
-    await containerAutograderService.getGraderByAssignmentId(assignmentId)
+    await containerAutograderService.loadGrader(assignmentId)
   if (!graderData || !makefileData || !autogradingImage || !timeout) {
     containerGrading = false
   } else {

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

@@ -2,8 +2,10 @@ import { NextFunction, Request, Response } from 'express'
 
 import UserCourseService from './userCourse.service'
 import { serialize } from './userCourse.serializer'
+import { serialize as userSerialize } from '../user/user.serializer'
 
 import { GenericResponse, NotFound, Updated } from '../../utils/apiResponse.utils'
+import UserService from '../user/user.service'
 
 export async function getAll(req: Request, res: Response, next: NextFunction) {
   try {
@@ -54,6 +56,25 @@ export async function detail(req: Request, res: Response, next: NextFunction) {
   }
 }
 
+export async function getInstructor(req: Request, res: Response, next: NextFunction) {
+  try {
+    const cid = parseInt(req.params.courseId)
+
+    const instructorInfo = await UserCourseService.instructor(cid)
+    if (!instructorInfo) return res.status(400).json({ message: `no instructors found for course ${cid}` })
+
+    const userInfo = await UserService.retrieve(instructorInfo.userId)
+    if (!userInfo) return res.status(400).json({ message: `no instructors found for course ${cid}` })
+
+    // strip out unnecessary info
+    const { isAdmin, createdAt, ...responsePayload } = userSerialize(userInfo)
+
+    res.status(200).json(responsePayload)
+  } catch (err) {
+    next(err)
+  }
+}
+
 export async function detailByUser(req: Request, res: Response, next: NextFunction) {
   try {
     const courseId = parseInt(req.params.courseId)
@@ -122,7 +143,7 @@ export async function checkEnroll(req: Request, res: Response, next: NextFunctio
 export async function _delete(req: Request, res: Response, next: NextFunction) {
   try {
     const id = parseInt(req.params.courseId)
-    console.log("DELETE PARAMS: ", req.params)
+    console.log('DELETE PARAMS: ', req.params)
     const currentUser = req.currentUser?.userId
     if (!currentUser) return res.status(401).json({ message: 'Unauthorized' })
 
@@ -140,7 +161,7 @@ export async function _delete(req: Request, res: Response, next: NextFunction) {
 export async function _deleteUser(req: Request, res: Response, next: NextFunction) {
   try {
     const courseID = parseInt(req.params.courseId)
-    console.log("DELETE PARAMS2: ", req.params)
+    console.log('DELETE PARAMS2: ', req.params)
     // const currentUser = req.currentUser?.userId
     const userID = parseInt(req.params.id)
     if (!userID) return res.status(401).json({ message: 'Unauthorized' })
@@ -194,4 +215,5 @@ export default {
   checkEnroll,
   addStudents,
   dropStudents,
+  getInstructor,
 }

devU-api/src/entities/userCourse/userCourse.router.ts

@@ -35,6 +35,40 @@ Router.get('/users', UserCourseController.checkEnroll)
  */
 Router.get('/', isAuthorized('courseViewAll'), UserCourseController.getByCourse)
 
+/**
+ * @swagger
+ * /course/:courseId/user-courses/instructor:
+ *   get:
+ *     summary: Retrieve first instructor of the course
+ *     tags:
+ *       - UserCourses
+ *     responses:
+ *       '200':
+ *         description: OK
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/User'
+ *       '404':
+ *         description: no instructor found associated with course
+ *         content:
+ *           application/json:
+ *             schema:
+ *                 type: object
+ *                 properties:
+ *                   message:
+ *                     type: string
+ *                     description: error message
+ *       parameters:
+ *       - name: courseId
+ *         description: Enter Course Id
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: integer
+ */
+Router.get('/instructor', isAuthorized('courseViewAll'), UserCourseController.getInstructor)
+
 /**
  * @swagger
  * /course/:courseId/user-courses/{id}:

devU-api/src/entities/userCourse/userCourse.service.ts

@@ -16,6 +16,13 @@ export async function create(userCourse: UserCourseType) {
   return await connect().save(userCourse)
 }
 
+export async function instructor(courseId: number) {
+  return await connect().findOne({
+    select: ['userId'],
+    where: { role: 'instructor', courseId: courseId, deletedAt: IsNull() },
+  })
+}
+
 // Add/drop students based on a list of users,
 // to drop students, set the third param to true
 export async function bulkAddDrop(userEmails: string[], courseId: number, drop: boolean) {
@@ -41,12 +48,12 @@ export async function bulkAddDrop(userEmails: string[], courseId: number, drop:
         try {
           await create(student)
         } catch (error) {
-            if (error instanceof Error && error.message === 'User already enrolled in course') {
-              // update student drop to false, since they re-enrolled after being dropped
-              await update(student)
-            } else {
-              throw error; // re-throw if it's a different error
-            }
+          if (error instanceof Error && error.message === 'User already enrolled in course') {
+            // update student drop to false, since they re-enrolled after being dropped
+            await update(student)
+          } else {
+            throw error // re-throw if it's a different error
+          }
         }
         success.push(`${email} enrolled successfully`)
       } else {
@@ -121,4 +128,5 @@ export default {
   listByUser,
   checking: checkIfEnrolled,
   bulkCreate: bulkAddDrop,
+  instructor,
 }

devU-api/src/router/courseData.router.ts

@@ -9,7 +9,6 @@ import assignmentProblem from '../entities/assignmentProblem/assignmentProblem.r
 import submissionProblemScore from '../entities/submissionProblemScore/submissionProblemScore.router'
 import deadlineExtensions from '../entities/deadlineExtensions/deadlineExtensions.router'
 import fileUpload from '../fileUpload/fileUpload.router'
-import categories from '../entities/category/category.router'
 import categoryScores from '../entities/categoryScore/categoryScore.router'
 import courseScores from '../entities/courseScore/courseScore.router'
 import assignmentScore from '../entities/assignmentScore/assignmentScore.router'
@@ -41,13 +40,16 @@ Router.use('/a/:assignmentId/', asInt('assignmentId'), assignmentRouter)
 
 Router.use('/assignments', assignments)
 Router.use('/assignment-scores', assignmentScore)
-Router.use('/categories', categories)
 Router.use('/category-scores', categoryScores)
 Router.use('/course-scores', courseScores)
 Router.use('/file-upload', fileUpload)
 Router.use('/roles', role)
 Router.use('/user-courses', userCourse)
 
+// redundant endpoint, assignment already encodes the categories
+// here if we need it in the future
+// Router.use('/categories', categories)
+
 Router.use('/webhooks', webhooksRouter)