Change Approach to Create Attempt on Entering Room

Author: Nephelite

backend/question-service/controllers/historyController.ts

@@ -40,15 +40,15 @@ export const createOrUpdateUserHistoryEntry = async (req: any, res: Response) =>
   try {
     const userId = req.userId;
 
-    const { questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode } = req.body;
+    const { questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode, isInitial } = req.body;
 
     if (!roomId) {
       return res.status(400).json({ error: "roomId is required" });
     }
 
     const existingEntry = await historyEntryModel.findOne({ userId, roomId });
 
-    if (existingEntry) {
+    if (!isInitial && existingEntry) {
       existingEntry.question = questionId;
       existingEntry.attemptStartedAt = attemptStartedAt;
       existingEntry.attemptCompletedAt = attemptCompletedAt;
@@ -58,20 +58,23 @@ export const createOrUpdateUserHistoryEntry = async (req: any, res: Response) =>
       const updatedEntry = await existingEntry.save();
 
       return res.status(200).json(updatedEntry);
-    } else {
+    } else if (!existingEntry) {
       const newHistoryEntry = new historyEntryModel({
         userId,
         question: questionId,
         roomId,
         attemptStartedAt,
         attemptCompletedAt,
         collaboratorId,
-        attemptCodes: [attemptCode],
+        attemptCodes: isInitial ? [attemptCode] : [],
       });
 
       const savedEntry = await newHistoryEntry.save();
 
       return res.status(201).json(savedEntry);
+    } else {
+      return res.status(200).json("Attempt already exists.");
+      // To reach here, this must be initial creation and there's an existing entry. No need to create new attempt.
     }
   } catch (error) {
     return res.status(500).json({ error: getErrorMessage(error) });

backend/question-service/models/HistoryEntry.ts

@@ -19,7 +19,7 @@ const historyEntrySchema: Schema = new Schema<HistoryEntry>({
   attemptStartedAt: { type: Date, required: true, default: Date.now() },
   attemptCompletedAt: { type: Date, required: true, default: Date.now() },
   collaboratorId: { type: String, required: true },
-  attemptCodes: [{ type: String, required: true }],
+  attemptCodes: [{ type: String }],
 });
 
 const historyEntryModel = mongoose.model<HistoryEntry>('historyEntry', historyEntrySchema);

frontend/src/data/repositories/HistoryRemoteDataSource.ts

@@ -13,8 +13,8 @@ export class HistoryRemoteDataSource extends BaseApi {
         return await this.protectedGet<HistoryEntry[]>("/");
     }
 
-    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
-        return await this.protectedPost<void>("/", { questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode });
+    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string, isInitial: boolean): Promise<void> {
+        return await this.protectedPost<void>("/", { questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode, isInitial });
     }
 
     async deleteSelectedHistories(selectedHistoryIds: string[]): Promise<void> {

frontend/src/data/repositories/HistoryRepositoryImpl.ts

@@ -8,8 +8,8 @@ export class HistoryRepositoryImpl {
         return this.dataSource.getAllUserHistories();
     }
 
-    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
-        this.dataSource.createOrUpdateUserHistory(questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode)
+    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string, isInitial: boolean): Promise<void> {
+        this.dataSource.createOrUpdateUserHistory(questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode, isInitial)
     }
 
     async deleteSelectedUserHistories(selectedHistoryIds: string[]): Promise<void> {

frontend/src/domain/repositories/IHistoryRepository.ts

@@ -2,7 +2,7 @@ import { HistoryEntry } from "domain/entities/HistoryEntry";
 
 export interface IHistoryRepository {
 	getAllUserHistories(): Promise<HistoryEntry[]>;
-    createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void>;
+    createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string, isInitial: boolean): Promise<void>;
     deleteSelectedUserHistories(selectedHistoryIds: string[]): Promise<void>;
     deleteAllUserHistories(): Promise<void>;
 }

frontend/src/domain/usecases/HistoryUseCases.ts

@@ -14,21 +14,37 @@ export class HistoryUseCases {
 		return allHistories;
     }
 
+    /**
+     * Creates a new User History Entry.
+     * (Note that just roomId isn't enough because the collaborator will also have a very similar History Entry)
+     * @returns Promise resolving when the history has been successfully created.
+     */
+    async createUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
+        if (!questionId || questionId.trim() === ""
+        || !roomId || roomId.trim() === "" 
+        || !attemptStartedAt || attemptStartedAt.trim() === "" 
+        || !attemptCompletedAt || attemptCompletedAt.trim() === "" 
+        || !collaboratorId || collaboratorId.trim() === "") {
+            throw new Error("Missing Attempt Details");
+        }
+        await this.historyRepository.createOrUpdateUserHistory(questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode, true);
+    }
+
     /**
      * Creates a new User History Entry. If there already exists a History Entry with the same userId (obtained in
      * backend via JWT token and not passed here) and roomId, update the existing one instead. 
      * (Note that just roomId isn't enough because the collaborator will also have a very similar History Entry)
      * @returns Promise resolving when the history has been successfully created.
      */
-    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
+    async updateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
         if (!questionId || questionId.trim() === ""
         || !roomId || roomId.trim() === "" 
         || !attemptStartedAt || attemptStartedAt.trim() === "" 
         || !attemptCompletedAt || attemptCompletedAt.trim() === "" 
         || !collaboratorId || collaboratorId.trim() === "") {
             throw new Error("Missing Attempt Details");
         }
-        await this.historyRepository.createOrUpdateUserHistory(questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode);
+        await this.historyRepository.createOrUpdateUserHistory(questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode, false);
     }
 
     /**

frontend/src/presentation/components/CodeEditor/LeaveButton.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React, { useEffect, useState } from "react";
 import { Button, Modal, message } from "antd";
 import { StopOutlined } from "@ant-design/icons";
 import styles from "./LeaveButton.module.css";
@@ -23,6 +23,7 @@ const LeaveButton: React.FC<LeaveButtonProps> = ({
     const navigate = useNavigate();
     const [isModalVisible, setIsModalVisible] = useState(false);
     const [editorContent, setEditorContent] = useState("");
+    const [created, setCreated] = useState(false);
 
     const showModal = () => {
         const content = getEditorText();
@@ -41,7 +42,7 @@ const LeaveButton: React.FC<LeaveButtonProps> = ({
 
     const handleSaveAndLeave = async () => {
         try {
-            await historyUseCases.createOrUpdateUserHistory(
+            await historyUseCases.updateUserHistory(
                 questionId,
                 roomId,
                 attemptStartedAt.getTime().toString(),
@@ -64,6 +65,24 @@ const LeaveButton: React.FC<LeaveButtonProps> = ({
         }
     };
 
+    useEffect(() => { //On init, send request to create attempt if it is absent.
+        const createEntry = async () => {
+            await historyUseCases.createUserHistory(
+                questionId,
+                roomId,
+                attemptStartedAt.getTime().toString(),
+                Date.now().toString(),
+                collaboratorId,
+                getEditorText(),
+            );
+        }
+        if (!roomId || !questionId || !attemptStartedAt || !collaboratorId || !getEditorText) return;
+        if (!created) {
+            setCreated(true);
+            createEntry();
+        };
+    }, [roomId, questionId, attemptStartedAt, collaboratorId, getEditorText, created])
+
     return (
         <>
             <Button

frontend/src/presentation/components/CodeEditor/SubmitButton.tsx

@@ -34,7 +34,7 @@ const SaveButton: React.FC<SaveButtonProps> = ({
 
     const handleSave = async () => {
         try {
-            await historyUseCases.createOrUpdateUserHistory(
+            await historyUseCases.updateUserHistory(
                 questionId,
                 roomId,
                 attemptStartedAt.getTime().toString(),