fixing encoding/decoding problem (#175)

* fixing encoding/decoding problem

* push learner attempt fixes

* updating learner timer and attempts

Author: MmagdyHafezZ

apps/api-gateway/package.json

@@ -17,7 +17,7 @@
     "start:debug": "yarn start --debug --watch",
     "start:dev": "yarn start --watch",
     "start:prod": "node dist/main",
-    "test": "jest",
+    "test": "jest --detectOpenHandles --forceExit",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "test:e2e": "jest --config ./test/jest-e2e.json",

apps/api/package.json

@@ -17,7 +17,7 @@
     "start:debug": "yarn start --debug --watch",
     "start:dev": "yarn start --watch",
     "start:prod": "node dist/main",
-    "test": "jest",
+    "test": "jest --detectOpenHandles --forceExit",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "test:e2e": "jest --config ./test/jest-e2e.json",

apps/api/src/api/assignment/attempt/attempt.service.ts

@@ -1523,7 +1523,13 @@ export class AttemptServiceV1 {
     const ongoingAttempts = attempts.filter(
       (sub) => !sub.submitted && (!sub.expiresAt || sub.expiresAt >= now),
     );
+    console.log(
+      `Found ${ongoingAttempts.length} ongoing attempts for user ${userSession.userId} on assignment ${assignment.id}`,
+    );
     if (ongoingAttempts.length > 0) {
+      console.log(
+        `User ${userSession.userId} has ongoing attempts for assignment ${assignment.id}`,
+      );
       throw new UnprocessableEntityException(IN_PROGRESS_SUBMISSION_EXCEPTION);
     }
     const attemptsInTimeRange = attempts.filter(

apps/api/src/api/assignment/attempt/dto/assignment-attempt/create.update.assignment.attempt.request.dto.ts

@@ -91,4 +91,12 @@ export class LearnerUpdateAssignmentAttemptRequestDto {
   @IsArray()
   @IsOptional()
   preTranslatedQuestions?: Map<number, QuestionDto>;
+
+  @ApiProperty({
+    description: "The expiration date of the assignment attempt",
+    type: Date,
+    required: false,
+  })
+  @IsOptional()
+  expiresAt?: Date;
 }

apps/api/src/api/attempt/services/attempt-submission.service.ts

@@ -76,6 +76,25 @@ export class AttemptSubmissionService {
     assignmentId: number,
     userSession: UserSession,
   ): Promise<BaseAssignmentAttemptResponseDto> {
+    const now = new Date();
+
+    const existingAttempt = await this.prisma.assignmentAttempt.findFirst({
+      where: {
+        assignmentId,
+        userId: userSession.userId,
+        submitted: false,
+        OR: [{ expiresAt: null }, { expiresAt: { gte: now } }],
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    if (existingAttempt) {
+      return {
+        id: existingAttempt.id,
+        success: true,
+      };
+    }
+
     const assignment = await this.assignmentRepository.findById(
       assignmentId,
       userSession,
@@ -116,7 +135,7 @@ export class AttemptSubmissionService {
 
     const assignmentAttempt = await this.prisma.assignmentAttempt.create({
       data: {
-        expiresAt: attemptExpiresAt,
+        expiresAt: attemptExpiresAt ?? null,
         submitted: false,
         assignmentId,
         assignmentVersionId: activeVersionId,
@@ -1088,12 +1107,14 @@ export class AttemptSubmissionService {
       authorAssignmentDetails,
       language,
       preTranslatedQuestions,
+      expiresAt: _ignoredExpiresAt,
       ...cleanedUpdateDto
     } = updateDto;
 
     return this.prisma.assignmentAttempt.update({
       data: {
         ...cleanedUpdateDto,
+        submitted: true,
         preferredLanguage: language ?? "en",
         expiresAt: new Date(),
         grade,
@@ -1148,7 +1169,7 @@ export class AttemptSubmissionService {
     ) {
       return new Date(Date.now() + assignment.allotedTimeMinutes * 60 * 1000);
     }
-    return undefined;
+    return null;
   }
 
   /**

apps/api/src/api/attempt/services/attempt-validation.service.ts

@@ -34,60 +34,44 @@ export class AttemptValidationService {
     const now = new Date();
     const timeRangeStartDate = this.calculateTimeRangeStartDate(assignment);
 
-    const attempts = await this.prisma.assignmentAttempt.findMany({
+    const activeAttempt = await this.prisma.assignmentAttempt.findFirst({
       where: {
         userId: userSession.userId,
         assignmentId: assignment.id,
+        submitted: false,
         OR: [
+          { expiresAt: null },
           {
-            submitted: false,
             expiresAt: {
               gte: now,
             },
           },
-          {
-            submitted: false,
-            expiresAt: undefined,
-          },
-          {
-            createdAt: {
-              gte: timeRangeStartDate,
-              lte: now,
-            },
-          },
         ],
       },
       orderBy: { createdAt: "desc" },
     });
 
-    const lastSubmittedAttempt = await this.prisma.assignmentAttempt.findFirst({
-      where: {
-        userId: userSession.userId,
-        assignmentId: assignment.id,
-        submitted: true,
-      },
-      orderBy: { expiresAt: "desc" },
-    });
-
-    const ongoingAttempts = attempts.filter(
-      (sub) => !sub.submitted && (!sub.expiresAt || sub.expiresAt >= now),
-    );
-
-    if (ongoingAttempts.length > 0) {
+    if (activeAttempt) {
       throw new UnprocessableEntityException(IN_PROGRESS_SUBMISSION_EXCEPTION);
     }
 
-    const attemptsInTimeRange = attempts.filter(
-      (sub) => sub.createdAt >= timeRangeStartDate && sub.createdAt <= now,
-    );
+    if (assignment.attemptsPerTimeRange) {
+      const attemptsInTimeRange = await this.prisma.assignmentAttempt.count({
+        where: {
+          userId: userSession.userId,
+          assignmentId: assignment.id,
+          createdAt: {
+            gte: timeRangeStartDate,
+            lte: now,
+          },
+        },
+      });
 
-    if (
-      assignment.attemptsPerTimeRange &&
-      attemptsInTimeRange.length >= assignment.attemptsPerTimeRange
-    ) {
-      throw new UnprocessableEntityException(
-        TIME_RANGE_ATTEMPTS_SUBMISSION_EXCEPTION_MESSAGE,
-      );
+      if (attemptsInTimeRange >= assignment.attemptsPerTimeRange) {
+        throw new UnprocessableEntityException(
+          TIME_RANGE_ATTEMPTS_SUBMISSION_EXCEPTION_MESSAGE,
+        );
+      }
     }
 
     if (assignment.numAttempts !== null && assignment.numAttempts !== -1) {
@@ -107,22 +91,45 @@ export class AttemptValidationService {
 
       if (
         attemptsBeforeCoolDown > 0 &&
+        cooldownMinutes > 0 &&
         totalAttempts >= attemptsBeforeCoolDown
       ) {
-        const lastAttemptTime = new Date(
-          lastSubmittedAttempt.expiresAt,
-        ).getTime();
-        const cooldownMs = cooldownMinutes * 60_000;
-        const nextEligibleTime = lastAttemptTime + cooldownMs;
-
-        if (now.getTime() < nextEligibleTime) {
-          throw new HttpException(
-            {
-              statusCode: HttpStatus.TOO_MANY_REQUESTS,
-              message: IN_COOLDOWN_PERIOD,
+        const lastSubmittedAttempt =
+          await this.prisma.assignmentAttempt.findFirst({
+            where: {
+              userId: userSession.userId,
+              assignmentId: assignment.id,
+              submitted: true,
             },
-            HttpStatus.TOO_MANY_REQUESTS,
-          );
+            orderBy: [{ expiresAt: "desc" }, { createdAt: "desc" }],
+          });
+
+        if (lastSubmittedAttempt) {
+          const lastAttemptReference =
+            lastSubmittedAttempt.expiresAt ?? lastSubmittedAttempt.createdAt;
+
+          if (lastAttemptReference) {
+            const referenceTimestamp = new Date(lastAttemptReference).getTime();
+
+            if (!Number.isNaN(referenceTimestamp)) {
+              const lastAttemptTime = Math.min(
+                referenceTimestamp,
+                now.getTime(),
+              );
+              const cooldownMs = cooldownMinutes * 60_000;
+              const nextEligibleTime = lastAttemptTime + cooldownMs;
+
+              if (now.getTime() < nextEligibleTime) {
+                throw new HttpException(
+                  {
+                    statusCode: HttpStatus.TOO_MANY_REQUESTS,
+                    message: IN_COOLDOWN_PERIOD,
+                  },
+                  HttpStatus.TOO_MANY_REQUESTS,
+                );
+              }
+            }
+          }
         }
       }
     }