feat: change minmax probability to minmax score

src/i18n/en/scoring.json

@@ -4,6 +4,6 @@
   },
   "errors": {
     "resultRangeOverlappingConstraint": "The specified score range has some overlaps with other records.",
-    "resultRangeMinMaxConstraint": "minProbability value should be less than maxProbability."
+    "resultRangeMinMaxConstraint": "minScore value should be less than maxScore."
   }
 }

src/i18n/fa/scoring.json

@@ -4,6 +4,6 @@
   },
   "errors": {
     "resultRangeOverlappingConstraint": "بازه امتیاز مشخص شده با بازه های دیگر تداخل دارد.",
-    "resultRangeMinMaxConstraint": "minProbability باید کمتر از maxProbability باشد."
+    "resultRangeMinMaxConstraint": "minScore باید کمتر از maxScore باشد."
   }
 }

src/migrations/1788950646073-ChangeResultRangeFields.ts

@@ -1,20 +1,35 @@
-import { MigrationInterface, QueryRunner } from "typeorm";
+import { MigrationInterface, QueryRunner } from 'typeorm';
 
 export class ChangeResultRangeFields1788950646073 implements MigrationInterface {
-    name = 'ChangeResultRangeFields1788950646073'
+  name = 'ChangeResultRangeFields1788950646073';
 
-    public async up(queryRunner: QueryRunner): Promise<void> {
+  public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(`ALTER TABLE "result_range" DROP COLUMN "minScore"`);
+    await queryRunner.query(
-        await queryRunner.query(`ALTER TABLE "result_range" DROP COLUMN "maxScore"`);
+      `ALTER TABLE "result_range" DROP COLUMN "minScore"`,
-        await queryRunner.query(`ALTER TABLE "result_range" ADD "minProbability" integer NOT NULL`);
+    );
-        await queryRunner.query(`ALTER TABLE "result_range" ADD "maxProbability" integer NOT NULL`);
+    await queryRunner.query(
-    }
+      `ALTER TABLE "result_range" DROP COLUMN "maxScore"`,
-
+    );
-    public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
-        await queryRunner.query(`ALTER TABLE "result_range" DROP COLUMN "maxProbability"`);
+      `ALTER TABLE "result_range" ADD "minProbability" integer NOT NULL`,
-        await queryRunner.query(`ALTER TABLE "result_range" DROP COLUMN "minProbability"`);
+    );
-        await queryRunner.query(`ALTER TABLE "result_range" ADD "maxScore" integer NOT NULL`);
+    await queryRunner.query(
-        await queryRunner.query(`ALTER TABLE "result_range" ADD "minScore" integer NOT NULL`);
+      `ALTER TABLE "result_range" ADD "maxProbability" integer NOT NULL`,
-    }
+    );
+  }
 
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "result_range" DROP COLUMN "maxProbability"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" DROP COLUMN "minProbability"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" ADD "maxScore" integer NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" ADD "minScore" integer NOT NULL`,
+    );
+  }
 }

src/migrations/1789906979798-CalculateByScore.ts

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CalculateByScore1789906979798 implements MigrationInterface {
+  name = 'CalculateByScore1789906979798';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "result_range" DROP COLUMN "minProbability"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" DROP COLUMN "maxProbability"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" ADD "minScore" integer NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" ADD "maxScore" integer NOT NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "result_range" DROP COLUMN "maxScore"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" DROP COLUMN "minScore"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" ADD "maxProbability" integer NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "result_range" ADD "minProbability" integer NOT NULL`,
+    );
+  }
+}

src/modules/admin/scoring/http/admin-scoring.post.endpoints.http

@@ -6,6 +6,6 @@ Content-Type: application/json
     "test": 4,
     "title": "احتمال خیلی بالا",
     "description": "احتمال ابتلا خیلی بالا است.",
-    "minProbability": 21,
+    "minScore": 21,
-    "maxProbability": 40
+    "maxScore": 40
 }

src/modules/scoring/dtos/create-result-range.dto.ts

@@ -8,11 +8,11 @@ export class CreateResultRangeDTO {
 
   @IsNumber()
   @IsNotEmpty()
-  minProbability!: number;
+  minScore!: number;
 
   @IsNumber()
   @IsNotEmpty()
-  maxProbability!: number;
+  maxScore!: number;
 
   @IsString()
   @IsNotEmpty()

src/modules/scoring/dtos/find-result-range.dto.ts

@@ -14,11 +14,11 @@ export class FindResultRangeDTO extends PartialType(PaginationQueryDTO) {
 
   @IsNumber()
   @IsOptional()
-  minProbability?: number;
+  minScore?: number;
 
   @IsNumber()
   @IsOptional()
-  maxProbability?: number;
+  maxScore?: number;
 
   @IsString()
   @IsOptional()

src/modules/scoring/entities/result-range.entity.ts

@@ -15,13 +15,13 @@ export class ResultRange {
     type: 'int',
     nullable: false,
   })
-  minProbability!: number;
+  minScore!: number;
 
   @Column({
     type: 'int',
     nullable: false,
   })
-  maxProbability!: number;
+  maxScore!: number;
 
   @Column({
     type: 'varchar',

src/modules/scoring/enums/result-range-sort-field.enum.ts

@@ -1,8 +1,8 @@
 export enum ResultRangeSortField {
   ID = 'id',
   TEST = 'test',
-  MIN_PROBABILITY = 'minProbability',
+  MIN_SCORE = 'minScore',
-  MAX_PROBABILITY = 'maxProbability',
+  MAX_SCORE = 'maxScore',
   TITLE = 'title',
   DESCRIPTION = 'description',
 }

src/modules/scoring/helpers/filter-result-ranges.helper.ts

@@ -17,12 +17,12 @@ export const filterResultRanges = (query: FindResultRangeDTO) => {
     where.title = ILike(`%${query.title}%`);
   }
 
-  if (query.maxProbability !== undefined) {
+  if (query.maxScore !== undefined) {
-    where.maxProbability = query.maxProbability;
+    where.maxScore = query.maxScore;
   }
 
-  if (query.minProbability !== undefined) {
+  if (query.minScore !== undefined) {
-    where.minProbability = query.minProbability;
+    where.minScore = query.minScore;
   }
 
   return where;

src/modules/scoring/providers/result-range-command.provider.ts

@@ -32,16 +32,16 @@ export class ResultRangeCommandProvider {
 
   private async checkRangeOverlap(
     test: number,
-    minProbability: number,
+    minScore: number,
-    maxProbability: number,
+    maxScore: number,
     excludeSelf: boolean = false,
   ): Promise<void> {
     const queryBuilder = this.resultRangeRepository
       .createQueryBuilder('resultRange')
       .where('resultRange.testId = :test', { test })
       .andWhere(
-        '(resultRange.minProbability BETWEEN :minProbability AND :maxProbability) OR (resultRange.maxProbability BETWEEN :minProbability AND :maxProbability) OR (:minProbability BETWEEN resultRange.minProbability AND resultRange.maxProbability) OR (:maxProbability BETWEEN resultRange.minProbability AND resultRange.maxProbability)',
+        '(resultRange.minScore BETWEEN :minScore AND :maxScore) OR (resultRange.maxScore BETWEEN :minScore AND :maxScore) OR (:minScore BETWEEN resultRange.minScore AND resultRange.maxScore) OR (:maxScore BETWEEN resultRange.minScore AND resultRange.maxScore)',
-        { minProbability, maxProbability },
+        { minScore, maxScore },
       );
 
     let overlappingRanges: Array<ResultRange>;
@@ -92,8 +92,8 @@ export class ResultRangeCommandProvider {
 
     await this.checkRangeOverlap(
       test.id,
-      createResultRangeDto.minProbability,
+      createResultRangeDto.minScore,
-      createResultRangeDto.maxProbability,
+      createResultRangeDto.maxScore,
     );
 
     const newResultRange = this.resultRangeRepository.create({
@@ -129,23 +129,23 @@ export class ResultRangeCommandProvider {
         ? updateResultRangeDto.test
         : resultRange.test.id;
 
-    const minProbability =
+    const minScore =
-      updateResultRangeDto.minProbability !== undefined
+      updateResultRangeDto.minScore !== undefined
-        ? updateResultRangeDto.minProbability
+        ? updateResultRangeDto.minScore
-        : resultRange.minProbability;
+        : resultRange.minScore;
 
-    const maxProbability =
+    const maxScore =
-      updateResultRangeDto.maxProbability !== undefined
+      updateResultRangeDto.maxScore !== undefined
-        ? updateResultRangeDto.maxProbability
+        ? updateResultRangeDto.maxScore
-        : resultRange.maxProbability;
+        : resultRange.maxScore;
 
-    if (minProbability >= maxProbability) {
+    if (minScore >= maxScore) {
       throw new BadRequestException(
         'scoring.errors.resultRangeMinMaxConstraint',
       );
     }
 
-    await this.checkRangeOverlap(testId, minProbability, maxProbability, true);
+    await this.checkRangeOverlap(testId, minScore, maxScore, true);
 
     Object.assign(resultRange, updateResultRangeDto);
 

src/modules/scoring/validators/result-range.validator.ts

@@ -14,15 +14,15 @@ export class ResultRangeValidator implements ValidatorConstraintInterface {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const obj = validationArguments?.object as any;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const { minProbability, maxProbability } = obj;
+    const { minScore, maxScore } = obj;
-    return minProbability < maxProbability;
+    return minScore < maxScore;
   }
   defaultMessage?(): string {
     const i18n = I18nContext.current();
 
     return (
       i18n?.t('scoring.errors.resultRangeMinMaxConstraint') ||
-      'minProbability value should be less than maxProbability.'
+      'minScore value should be less than maxScore.'
     );
   }
 }

src/modules/submissions/providers/answer/calculate-result.provider.ts

@@ -72,12 +72,12 @@ export class CalculateResultProvider {
             rangeRules: true,
           },
         }),
-      async (probability) =>
+      async (score) =>
         manager.find(ResultRange, {
           where: {
             test: { id: submission.test.id },
-            minProbability: LessThanOrEqual(probability),
+            minScore: LessThanOrEqual(score),
-            maxProbability: MoreThanOrEqual(probability),
+            maxScore: MoreThanOrEqual(score),
           },
         }),
     );
@@ -119,12 +119,12 @@ export class CalculateResultProvider {
             rangeRules: true,
           },
         }),
-      async (probability) =>
+      async (score) =>
         this.resultRangeRepository.find({
           where: {
             test: { id: submission.testId },
-            minProbability: LessThanOrEqual(probability),
+            minScore: LessThanOrEqual(score),
-            maxProbability: MoreThanOrEqual(probability),
+            maxScore: MoreThanOrEqual(score),
           },
         }),
     );
@@ -150,7 +150,7 @@ export class CalculateResultProvider {
       numericValue?: number;
     }>,
     loadQuestions: (questionIds: number[]) => Promise<Question[]>,
-    loadResultRanges: (probability: number) => Promise<ResultRange[]>,
+    loadResultRanges: (score: number) => Promise<ResultRange[]>,
   ) {
     let score = 0;
 
@@ -242,7 +242,7 @@ export class CalculateResultProvider {
     const probability =
       totalScores > 0 ? Math.ceil((score / totalScores) * 100) : 0;
 
-    const resultRanges = await loadResultRanges(probability);
+    const resultRanges = await loadResultRanges(score);
 
     return {
       score,