implement reset last submission route

src/controllers/user.ts

@@ -227,6 +227,35 @@ const userController = {
         }
     },
 
+    resetLastSubmission: async (req: Request, res: Response) => {
+        const errors = validationResult(req);
+        if (!errors.isEmpty()) {
+            res.status(statusCodes.MISSING_PARAMS).json(
+                errors.formatWith(errorMessage).array()[0]
+            );
+        } else {
+            try {
+                const { userId } = req.params;
+                await userDBInteractions.resetLastSubmission(userId);
+                const user: IUserModel = await userDBInteractions.find(userId);
+                if (!user)
+                    res.status(statusCodes.NOT_FOUND).json({
+                        status: statusCodes.NOT_FOUND,
+                        message: "User not found"
+                    });
+                else {
+                    const updatedUser: IUserModel = await userDBInteractions.update(
+                        userId,
+                        user
+                    );
+                    res.status(statusCodes.SUCCESS).json(updatedUser);
+                }
+            } catch (error) {
+                res.status(statusCodes.SERVER_ERROR).json(error);
+            }
+        }
+    },
+
     resetLastSubmissions: async (req: Request, res: Response) => {
         try {
             await userDBInteractions.resetLastSubmissions();

src/database/interactions/user.ts

@@ -33,6 +33,15 @@ export const userDBInteractions = {
         return User.findByIdAndDelete(userId).exec();
     },
 
+    resetLastSubmission: (userId: string): Promise<IUserModel> => {
+        return User.updateOne(
+            { _id: userId },
+            {
+                $set: { "platformData.codeforces.lastSubmission": {} }
+            }
+        ).exec();
+    },
+
     resetLastSubmissions: (): Promise<IUserModel[]> => {
         return User.updateMany(
             {},

src/routes/user.ts

@@ -20,6 +20,12 @@ userRouter.put(
     userController.update
 );
 
+userRouter.patch(
+    "/:userId/resetLastSubmission",
+    userValidator("PATCH /users/:userId/resetLastSubmission"),
+    userController.resetLastSubmission
+);
+
 userRouter.patch("/resetLastSubmissions", userController.resetLastSubmissions);
 
 userRouter.patch(

src/validators/user.ts

@@ -71,6 +71,9 @@ export function userValidator(method: string): ValidationChain[] {
                 ).custom(validPassword)
             ];
         }
+        case "PATCH /users/:userId/resetLastSubmission": {
+            return [param("userId", "Invalid ':userId'").isMongoId()];
+        }
         case "PATCH /users/:userId/problems": {
             return [
                 param("userId", "Invalid ':userId'").isMongoId(),

tests/unit/controllers/user.test.ts

@@ -32,7 +32,12 @@ const testUser: IUserModel = new User({
     platformData: {
         codeforces: {
             username: "test",
-            email: "[email protected]"
+            email: "[email protected]",
+            lastSubmission: {
+                problemId: "6e0d9ca7d2e93b127f941e1566b6253aa48dab48",
+                isComplete: "true",
+                status: "OK"
+            }
         }
     },
     _id: "5ed7505cf09e10001e5084b7"
@@ -110,6 +115,70 @@ describe("Users controller tests", () => {
     });
 
     describe("ResetLastSubmission", () => {
+        let req;
+        beforeEach(() => {
+            req = mockReq({
+                params: {
+                    userId: testUser._id
+                }
+            });
+        });
+        it("status 200: resets last submission", async () => {
+            const updatedUser = JSON.parse(JSON.stringify(testUser));
+            updatedUser.platformData.codeforces.lastSubmission = {};
+            stubs.userValidator.validationResult.returns(
+                emptyValidationError()
+            );
+            stubs.userDB.find.returns(testUser);
+            stubs.userDB.update.returns(updatedUser);
+            await userController.resetLastSubmission(req, mockRes);
+            sinon.assert.calledOnce(stubs.userDB.resetLastSubmission);
+            sinon.assert.calledOnce(stubs.userDB.find);
+            sinon.assert.calledOnce(stubs.userDB.update);
+            sinon.assert.calledOnce(stubs.userValidator.validationResult);
+            sinon.assert.calledWith(mockRes.status, statusCodes.SUCCESS);
+            sinon.assert.calledWith(mockRes.json, updatedUser);
+        });
+
+        it("status 404: returns an appropriate response if user with given id doesn't exist", async () => {
+            stubs.userValidator.validationResult.returns(
+                emptyValidationError()
+            );
+            await userController.resetLastSubmission(req, mockRes);
+            sinon.assert.calledOnce(stubs.userValidator.validationResult);
+            sinon.assert.calledWith(mockRes.status, statusCodes.NOT_FOUND);
+            sinon.assert.calledWith(mockRes.json, {
+                status: statusCodes.NOT_FOUND,
+                message: "User not found"
+            });
+        });
+
+        it("status 422: returns an appropriate response with validation error", async () => {
+            const errorMsg = {
+                status: statusCodes.MISSING_PARAMS,
+                message: "params[userId]: Invalid or missing ':userId'"
+            };
+            req.params.userId = "not ObjectId";
+            stubs.userValidator.validationResult.returns(
+                validationErrorWithMessage(errorMsg)
+            );
+            await userController.resetLastSubmission(req, mockRes);
+            sinon.assert.calledOnce(stubs.userValidator.validationResult);
+            sinon.assert.calledWith(mockRes.status, statusCodes.MISSING_PARAMS);
+            sinon.assert.calledWith(mockRes.json, errorMsg);
+        });
+
+        it("status 500: fails to reset last submission", async () => {
+            stubs.userValidator.validationResult.returns(
+                emptyValidationError()
+            );
+            stubs.userDB.resetLastSubmission.throws();
+            await userController.resetLastSubmission(req, mockRes);
+            sinon.assert.calledWith(mockRes.status, statusCodes.SERVER_ERROR);
+        });
+    });
+
+    describe("ResetLastSubmissions", () => {
         it("status 200: resets last submissions", async () => {
             await userController.resetLastSubmissions(mockReq, mockRes);
             sinon.assert.calledOnce(stubs.userDB.resetLastSubmissions);

tests/unit/stubs/user.ts

@@ -12,6 +12,10 @@ export const userDBInteractionsStubs = () => {
         findByUsername: sinon.stub(userDBInteractions, "findByUsername"),
         update: sinon.stub(userDBInteractions, "update"),
         delete: sinon.stub(userDBInteractions, "delete"),
+        resetLastSubmission: sinon.stub(
+            userDBInteractions,
+            "resetLastSubmission"
+        ),
         resetLastSubmissions: sinon.stub(
             userDBInteractions,
             "resetLastSubmissions"
@@ -25,6 +29,7 @@ export const userDBInteractionsStubs = () => {
             this.findByUsername.restore();
             this.update.restore();
             this.delete.restore();
+            this.resetLastSubmission.restore();
             this.resetLastSubmissions.restore();
         }
     };