feat: change result range check field

src/i18n/en/scoring.json

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

src/i18n/fa/scoring.json

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

src/migrations/1788950646073-ChangeResultRangeFields.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class ChangeResultRangeFields1788950646073 implements MigrationInterface {
+    name = 'ChangeResultRangeFields1788950646073'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "result_range" DROP COLUMN "minScore"`);
+        await queryRunner.query(`ALTER TABLE "result_range" DROP COLUMN "maxScore"`);
+        await queryRunner.query(`ALTER TABLE "result_range" ADD "minProbability" integer NOT NULL`);
+        await queryRunner.query(`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/modules/admin/scoring/http/admin-scoring.post.endpoints.http

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

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

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

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

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

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

@@ -15,13 +15,13 @@ export class ResultRange {
     type: 'int',
     nullable: false,
   })
-  minScore!: number;
+  minProbability!: number;
 
   @Column({
     type: 'int',
     nullable: false,
   })
-  maxScore!: number;
+  maxProbability!: 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_SCORE = 'minScore',
-  MAX_SCORE = 'maxScore',
+  MIN_PROBABILITY = 'minProbability',
+  MAX_PROBABILITY = 'maxProbability',
   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.maxScore !== undefined) {
-    where.maxScore = query.maxScore;
+  if (query.maxProbability !== undefined) {
+    where.maxProbability = query.maxProbability;
   }
 
-  if (query.minScore !== undefined) {
-    where.minScore = query.minScore;
+  if (query.minProbability !== undefined) {
+    where.minProbability = query.minProbability;
   }
 
   return where;

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

@@ -32,16 +32,16 @@ export class ResultRangeCommandProvider {
 
   private async checkRangeOverlap(
     test: number,
-    minScore: number,
-    maxScore: number,
+    minProbability: number,
+    maxProbability: number,
     excludeSelf: boolean = false,
   ): Promise<void> {
     const queryBuilder = this.resultRangeRepository
       .createQueryBuilder('resultRange')
       .where('resultRange.testId = :test', { test })
       .andWhere(
-        '(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)',
-        { minScore, maxScore },
+        '(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)',
+        { minProbability, maxProbability },
       );
 
     let overlappingRanges: Array<ResultRange>;
@@ -92,8 +92,8 @@ export class ResultRangeCommandProvider {
 
     await this.checkRangeOverlap(
       test.id,
-      createResultRangeDto.minScore,
-      createResultRangeDto.maxScore,
+      createResultRangeDto.minProbability,
+      createResultRangeDto.maxProbability,
     );
 
     const newResultRange = this.resultRangeRepository.create({
@@ -129,23 +129,23 @@ export class ResultRangeCommandProvider {
         ? updateResultRangeDto.test
         : resultRange.test.id;
 
-    const minScore =
-      updateResultRangeDto.minScore !== undefined
-        ? updateResultRangeDto.minScore
-        : resultRange.minScore;
+    const minProbability =
+      updateResultRangeDto.minProbability !== undefined
+        ? updateResultRangeDto.minProbability
+        : resultRange.minProbability;
 
-    const maxScore =
-      updateResultRangeDto.maxScore !== undefined
-        ? updateResultRangeDto.maxScore
-        : resultRange.maxScore;
+    const maxProbability =
+      updateResultRangeDto.maxProbability !== undefined
+        ? updateResultRangeDto.maxProbability
+        : resultRange.maxProbability;
 
-    if (minScore >= maxScore) {
+    if (minProbability >= maxProbability) {
       throw new BadRequestException(
         'scoring.errors.resultRangeMinMaxConstraint',
       );
     }
 
-    await this.checkRangeOverlap(testId, minScore, maxScore, true);
+    await this.checkRangeOverlap(testId, minProbability, maxProbability, 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 { minScore, maxScore } = obj;
-    return minScore < maxScore;
+    const { minProbability, maxProbability } = obj;
+    return minProbability < maxProbability;
   }
   defaultMessage?(): string {
     const i18n = I18nContext.current();
 
     return (
       i18n?.t('scoring.errors.resultRangeMinMaxConstraint') ||
-      'minScore value should be less than maxScore.'
+      'minProbability value should be less than maxProbability.'
     );
   }
 }

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

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