104 grading opts

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

@@ -11,6 +11,8 @@ import {
 
 import CourseModel from '../course/course.model'
 
+import { ScoringType } from 'devu-shared-modules'
+
 @Entity('assignments')
 export default class AssignmentModel {
   /**
@@ -58,6 +60,11 @@ export default class AssignmentModel {
    *          type: string
    *          array: true
    *          description: filenames of stored attachments, matches the index of the fileHashes, i.e. filename[i] is the name of hash[i]
+ *        scoringType:
+ *          type: string
+ *          enum: [highest-score, latest-submission, no-score]
+ *          default: highest-score
+ *          description: Determines how the final score is chosen for the assignment
    */
 
   @PrimaryGeneratedColumn()
@@ -109,4 +116,12 @@ export default class AssignmentModel {
 
   @Column({ name: 'attachmentsFilenames', array: true, default: [], type: 'text', nullable: false })
   attachmentsFilenames: string[]
+
+  @Column({
+    type: 'enum',
+    enum: ScoringType,
+    default: ScoringType.HIGHEST_SCORE,
+    name: 'scoring_type'
+  })
+  scoringType: ScoringType
 }

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

@@ -123,8 +123,10 @@ Router.get('/:assignmentId', asInt('assignmentId'), isAuthorizedByAssignmentStat
  *     tags:
  *       - Assignments
  *     responses:
- *       '200':
- *         description: OK
+ *       '201':
+ *         description: Created
+ *       '400':
+ *         description: Bad Request
  *     parameters:
  *       - name: courseId
  *         in: path
@@ -136,7 +138,41 @@ Router.get('/:assignmentId', asInt('assignmentId'), isAuthorizedByAssignmentStat
  *       content:
  *         application/x-www-form-urlencoded:
  *           schema:
- *             $ref: '#/components/schemas/Assignment'
+ *             type: object
+ *             required: [courseId, name, categoryName, maxFileSize, disableHandins, startDate, dueDate, endDate]
+ *             properties:
+ *               courseId:
+ *                 type: integer
+ *               name:
+ *                 type: string
+ *                 maxLength: 128
+ *               categoryName:
+ *                 type: string
+ *                 maxLength: 128
+ *               description:
+ *                 type: string
+ *                 nullable: true
+ *               maxFileSize:
+ *                 type: integer
+ *               maxSubmissions:
+ *                 type: integer
+ *                 nullable: true
+ *               disableHandins:
+ *                 type: boolean
+ *               startDate:
+ *                 type: string
+ *                 format: date-time
+ *               dueDate:
+ *                 type: string
+ *                 format: date-time
+ *               endDate:
+ *                 type: string
+ *                 format: date-time
+ *               scoringType:
+ *                 type: string
+ *                 enum: [highest-score, latest-submission, no-score]
+ *                 default: highest-score
+ *                 description: Determines how the final score is chosen for the assignment
  */
 
 
@@ -151,7 +187,9 @@ Router.post('/', isAuthorized('assignmentEditAll'), upload.array('files', 5), va
  *       - Assignments
  *     responses:
  *       '200':
- *         description: OK
+ *         description: Updated
+ *       '404':
+ *         description: Not Found
  *     parameters:
  *       - name: courseId
  *         in: path
@@ -168,7 +206,37 @@ Router.post('/', isAuthorized('assignmentEditAll'), upload.array('files', 5), va
  *       content:
  *         application/x-www-form-urlencoded:
  *           schema:
- *             $ref: '#/components/schemas/Assignment'
+ *             type: object
+ *             properties:
+ *               name:
+ *                 type: string
+ *                 maxLength: 128
+ *               categoryName:
+ *                 type: string
+ *                 maxLength: 128
+ *               description:
+ *                 type: string
+ *                 nullable: true
+ *               maxFileSize:
+ *                 type: integer
+ *               maxSubmissions:
+ *                 type: integer
+ *                 nullable: true
+ *               disableHandins:
+ *                 type: boolean
+ *               startDate:
+ *                 type: string
+ *                 format: date-time
+ *               dueDate:
+ *                 type: string
+ *                 format: date-time
+ *               endDate:
+ *                 type: string
+ *                 format: date-time
+ *               scoringType:
+ *                 type: string
+ *                 enum: [highest-score, latest-submission, no-score]
+ *                 description: Determines how the final score is chosen for the assignment
  */
 Router.put(
   '/:assignmentId',

devU-api/src/entities/assignment/assignment.serializer.ts

@@ -17,7 +17,8 @@ export function serialize(assignment: AssignmentModel): Assignment {
     disableHandins: assignment.disableHandins,
     createdAt: assignment.createdAt.toISOString(),
     updatedAt: assignment.updatedAt.toISOString(),
+    scoringType: assignment.scoringType,
     attachmentsHashes: assignment.attachmentsHashes,
-    attachmentsFilenames: assignment.attachmentsFilenames
+    attachmentsFilenames: assignment.attachmentsFilenames,
   }
 }

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

@@ -28,6 +28,7 @@ export async function update(assignment: Assignment) {
     disableHandins,
     attachmentsHashes,
     attachmentsFilenames,
+    scoringType,
   } = assignment
 
   if (!id) throw new Error('Missing Id')
@@ -44,6 +45,7 @@ export async function update(assignment: Assignment) {
     disableHandins,
     attachmentsHashes,
     attachmentsFilenames,
+    scoringType,
   })
 }
 

devU-api/src/entities/assignment/assignment.validator.ts

@@ -2,6 +2,7 @@ import { check } from 'express-validator'
 
 import validate from '../../middleware/validator/generic.validator'
 import { isBeforeParam, isAfterParam } from '../../middleware/validator/date.validator'
+import { ScoringType } from 'devu-shared-modules'
 
 const courseId = check('courseId').isNumeric()
 const name = check('name').isString().trim().isLength({ max: 128 })
@@ -10,6 +11,10 @@ const description = check('description').isString().trim()
 const maxFileSize = check('maxFileSize').isNumeric()
 const maxSubmissions = check('maxSubmissions').isNumeric().optional({ nullable: true })
 const disableHandins = check('disableHandins').isBoolean()
+const scoringType = check('scoringType')
+  .optional()
+  .isIn(Object.values(ScoringType))
+  .withMessage(`scoringType must be one of: ${Object.values(ScoringType).join(', ')}`)
 
 const startDate = check('startDate')
   .trim()
@@ -43,6 +48,7 @@ const validator = [
   maxFileSize,
   maxSubmissions,
   disableHandins,
+  scoringType,
   validate,
 ]
 

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

@@ -11,6 +11,7 @@ import {
   AssignmentProblem,
   AssignmentScore,
   NonContainerAutoGrader,
+  ScoringType,
   Submission,
   SubmissionProblemScore,
   SubmissionScore,
@@ -25,6 +26,7 @@ import { downloadFile, initializeMinio } from '../../fileStorage'
 import { createNewLab, sendSubmission, waitForJob } from '../../autograders/leviathan.service'
 import { DockerFile, LabData, LabFile, SubmissionFile } from 'leviathan-node-sdk'
 import path from 'path'
+import assignmentService from '../assignment/assignment.service'
 
 async function grade(submissionId: number) {
   const submissionModel = await submissionService.retrieve(submissionId)
@@ -271,11 +273,27 @@ export async function callbackFailure(assignmentId: number, submissionId: number
 //Currently just sets assignmentscore to the latest submission. Pulled this function out for easy future modification.
 async function updateAssignmentScore(submission: Submission, score: number) {
   const assignmentScoreModel = await assignmentScoreService.retrieveByUser(submission.assignmentId, submission.userId)
+  const assignment = await assignmentService.retrieve(submission.assignmentId, submission.courseId)
+
   if (assignmentScoreModel) {
     //If assignmentScore already exists, update existing entity
     const assignmentScore = serializeAssignmentScore(assignmentScoreModel)
     assignmentScore.score = score
-    assignmentScoreService.update(assignmentScore)
+
+    // todo use scoring type in assignment entity, leaving this alone for now,
+    //  grader endpoint needs to be refactored
+    switch (assignment!.scoringType) {
+      case ScoringType.HIGHEST_SCORE:
+        break
+      case ScoringType.LATEST_SUBMISSION:
+        break
+      case ScoringType.NO_SCORE:
+        break
+      default:
+        break
+    }
+
+    await assignmentScoreService.update(assignmentScore)
   } else {
     //Otherwise create a new one
     const assignmentScore: AssignmentScore = {

devU-api/src/migration/1744570382000-addScoringType.ts

@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddScoringType1744570382000 implements MigrationInterface {
+    name = 'AddScoringType1744570382000'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TYPE "public"."assignments_scoring_type_enum" AS ENUM('highest-score', 'latest-submission', 'no-score')`);
+        await queryRunner.query(`ALTER TABLE "assignments" ADD "scoring_type" "public"."assignments_scoring_type_enum" NOT NULL DEFAULT 'highest-score'`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "assignments" DROP COLUMN "scoring_type"`);
+        await queryRunner.query(`DROP TYPE "public"."assignments_scoring_type_enum"`);
+    }
+
+}

devU-shared/src/types/assignment.types.ts

@@ -1,3 +1,9 @@
+export enum ScoringType {
+  HIGHEST_SCORE = 'highest-score',
+  LATEST_SUBMISSION = 'latest-submission',
+  NO_SCORE = 'no-score'
+}
+
 export type Assignment = {
   id?: number
   courseId: number
@@ -14,5 +20,6 @@ export type Assignment = {
   updatedAt?: string
   attachmentsHashes ?: string[]
   attachmentsFilenames ?: string[]
+  scoringType?: ScoringType
 }