feat: add nudge application functionality (#2542) (#2553)

* feat: add nudge application functionality

- Introduced a new endpoint to nudge applications, allowing users to send reminders.
- Implemented logic to prevent nudging if the last nudge was less than 24 hours ago, with appropriate error messages.
- Updated application constants to include new API response and error messages related to the nudge feature.
- Enhanced the applications controller to handle nudge requests and update application nudge counts accordingly.

* refactor: enhance nudge application logic

* feat: add error handling for nudge application when status is not pending

* fix: correct last nudge timestamp logic in nudgeApplication function

* refactor: improve nudge application logic and update response messages

- Enhanced the nudgeApplication function to streamline error handling and improve readability.
- Updated API response and error messages for nudging applications to provide clearer feedback.
- Removed redundant checks and utilized a transaction for better performance and consistency in the nudge process.

* refactor:  add NUDGE_APPLICATION_STATUS constants

* test: add comprehensive tests for nudge application functionality (#2543)

* test: add comprehensive tests for nudge application functionality

* chore: add logger utility to discordService and logService for improved logging

* test: enhance nudge application tests to cover pending status validation

* refactor: remove duplicate logger import and unused config in discordService

* nit: remove unused logger import

* refactor: update nudge application logic and messages

- Changed the success message for nudging an application to "Nudge sent successfully".
- Updated error messages for nudging to be more user-friendly.
- Refactored the nudgeApplication function to streamline logic and improve readability.
- Adjusted integration and unit tests to reflect the updated messages and logic.

* refactor: nudge model try and catch block

---------

Co-authored-by: Amit Prakash <[email protected]>

Author: iamitprakash

constants/application.ts

@@ -17,12 +17,23 @@ const APPLICATION_ROLES = {
 const API_RESPONSE_MESSAGES = {
   APPLICATION_CREATED_SUCCESS: "Application created successfully",
   APPLICATION_RETURN_SUCCESS: "Applications returned successfully",
+  NUDGE_SUCCESS: "Nudge sent successfully",
 };
 
 const APPLICATION_ERROR_MESSAGES = {
   APPLICATION_ALREADY_REVIEWED: "Application has already been reviewed",
+  NUDGE_TOO_SOON: "Nudge unavailable. You'll be able to nudge again after 24 hours.",
+  NUDGE_ONLY_PENDING_ALLOWED: "Nudge unavailable. Only pending applications can be nudged.",
 };
 
+const NUDGE_APPLICATION_STATUS = {
+  notFound: "notFound",
+  unauthorized: "unauthorized",
+  notPending: "notPending",
+  tooSoon: "tooSoon",
+  success: "success",
+} as const;
+
 /**
  * Business requirement: Applications created after this date are considered reviewed
  * and cannot be resubmitted. This date marks the start of the new application review cycle.
@@ -35,4 +46,5 @@ module.exports = {
   API_RESPONSE_MESSAGES,
   APPLICATION_ERROR_MESSAGES,
   APPLICATION_REVIEW_CYCLE_START_DATE,
+  NUDGE_APPLICATION_STATUS,
 };

controllers/applications.ts

@@ -3,10 +3,11 @@ const { logType } = require("../constants/logs");
 import { CustomRequest, CustomResponse } from "../types/global";
 const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
 const ApplicationModel = require("../models/applications");
-const { API_RESPONSE_MESSAGES } = require("../constants/application");
+const { API_RESPONSE_MESSAGES, APPLICATION_ERROR_MESSAGES, NUDGE_APPLICATION_STATUS } = require("../constants/application");
 const { createApplicationService } = require("../services/applicationService");
 const { Conflict } = require("http-errors");
 const logger = require("../utils/logger");
+const { APPLICATION_STATUS_TYPES } = require("../constants/application");
 
 const getAllOrUserApplication = async (req: CustomRequest, res: CustomResponse): Promise<any> => {
   try {
@@ -149,9 +150,43 @@ const getApplicationById = async (req: CustomRequest, res: CustomResponse) => {
   }
 };
 
+const nudgeApplication = async (req: CustomRequest, res: CustomResponse) => {
+  try {
+    const { applicationId } = req.params;
+
+    const result = await ApplicationModel.nudgeApplication({
+      applicationId,
+      userId: req.userData.id,
+    });
+
+    switch (result.status) {
+      case NUDGE_APPLICATION_STATUS.notFound:
+        return res.boom.notFound("Application not found");
+      case NUDGE_APPLICATION_STATUS.unauthorized:
+        return res.boom.unauthorized("You are not authorized to nudge this application");
+      case NUDGE_APPLICATION_STATUS.notPending:
+        return res.boom.badRequest(APPLICATION_ERROR_MESSAGES.NUDGE_ONLY_PENDING_ALLOWED);
+      case NUDGE_APPLICATION_STATUS.tooSoon:
+        return res.boom.tooManyRequests(APPLICATION_ERROR_MESSAGES.NUDGE_TOO_SOON);
+      case NUDGE_APPLICATION_STATUS.success:
+        return res.json({
+          message: API_RESPONSE_MESSAGES.NUDGE_SUCCESS,
+          nudgeCount: result.nudgeCount,
+          lastNudgeAt: result.lastNudgeAt,
+        });
+      default:
+        return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+    }
+  } catch (err) {
+    logger.error(`Error while nudging application: ${err}`);
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+  }
+};
+
 module.exports = {
   getAllOrUserApplication,
   addApplication,
   updateApplication,
   getApplicationById,
+  nudgeApplication,
 };

models/applications.ts

@@ -2,7 +2,8 @@ import { application } from "../types/application";
 const firestore = require("../utils/firestore");
 const logger = require("../utils/logger");
 const ApplicationsModel = firestore.collection("applicants");
-const { DOCUMENT_WRITE_SIZE } = require("../constants/constants");
+const { APPLICATION_STATUS_TYPES, NUDGE_APPLICATION_STATUS } = require("../constants/application");
+const { convertDaysToMilliseconds } = require("../utils/time");
 
 const getAllApplications = async (limit: number, lastDocId?: string) => {
   try {
@@ -136,11 +137,63 @@ const updateApplication = async (dataToUpdate: object, applicationId: string) =>
   }
 };
 
+const nudgeApplication = async ({ applicationId, userId }: { applicationId: string; userId: string }) => {
+  const currentTime = Date.now();
+  const twentyFourHoursInMilliseconds = convertDaysToMilliseconds(1);
+
+  const result = await firestore.runTransaction(async (transaction) => {
+    const applicationRef = ApplicationsModel.doc(applicationId);
+    const applicationDoc = await transaction.get(applicationRef);
+
+    if (!applicationDoc.exists) {
+      return { status: NUDGE_APPLICATION_STATUS.notFound };
+    }
+
+    const application = applicationDoc.data();
+
+    if (application.userId !== userId) {
+      return { status: NUDGE_APPLICATION_STATUS.unauthorized };
+    }
+
+    if (application.status !== APPLICATION_STATUS_TYPES.PENDING) {
+      return { status: NUDGE_APPLICATION_STATUS.notPending };
+    }
+
+    const lastNudgeAt = application.lastNudgeAt;
+    if (lastNudgeAt) {
+      const lastNudgeTimestamp = new Date(lastNudgeAt).getTime();
+      const timeDifference = currentTime - lastNudgeTimestamp;
+
+      if (timeDifference <= twentyFourHoursInMilliseconds) {
+        return { status: NUDGE_APPLICATION_STATUS.tooSoon };
+      }
+    }
+
+    const currentNudgeCount = application.nudgeCount || 0;
+    const updatedNudgeCount = currentNudgeCount + 1;
+    const newLastNudgeAt = new Date(currentTime).toISOString();
+
+    transaction.update(applicationRef, {
+      nudgeCount: updatedNudgeCount,
+      lastNudgeAt: newLastNudgeAt,
+    });
+
+    return {
+      status: NUDGE_APPLICATION_STATUS.success,
+      nudgeCount: updatedNudgeCount,
+      lastNudgeAt: newLastNudgeAt,
+    };
+  });
+
+  return result;
+};
+
 module.exports = {
   getAllApplications,
   getUserApplications,
   addApplication,
   updateApplication,
   getApplicationsBasedOnStatus,
   getApplicationById,
+  nudgeApplication,
 };

routes/applications.ts

@@ -24,5 +24,6 @@ router.patch(
   applicationValidator.validateApplicationUpdateData,
   applications.updateApplication
 );
+router.patch("/:applicationId/nudge", authenticate, applications.nudgeApplication);
 
 module.exports = router;

services/logService.ts

@@ -19,7 +19,11 @@ interface LogBody {
  * @param meta { LogMeta }: Meta data of the log
  * @param body { LogBody }: Body of the log
  */
-export const addLog = async (type: string, meta: LogMeta, body: LogBody): Promise<FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>> => {
+export const addLog = async (
+  type: string,
+  meta: LogMeta,
+  body: LogBody
+): Promise<FirebaseFirestore.DocumentReference<FirebaseFirestore.DocumentData>> => {
   try {
     const log = {
       type,
@@ -32,4 +36,4 @@ export const addLog = async (type: string, meta: LogMeta, body: LogBody): Promis
     logger.error("Error in adding log", err);
     throw new Error(INTERNAL_SERVER_ERROR);
   }
-};
+};

test/integration/application.test.ts

@@ -2,17 +2,17 @@ import chai from "chai";
 import chaiHttp from "chai-http";
 const { expect } = chai;
 import config from "config";
+import sinon from "sinon";
 const app = require("../../server");
 const addUser = require("../utils/addUser");
 const cleanDb = require("../utils/cleanDb");
 const authService = require("../../services/authService");
 const userData = require("../fixtures/user/user")();
 const applicationModel = require("../../models/applications");
-const { requestRoleData } = require("../fixtures/discordactions/discordactions");
 
 const applicationsData = require("../fixtures/applications/applications")();
 const cookieName = config.get("userToken.cookieName");
-const { getUserApplicationObject } = require("../../utils/application");
+const { APPLICATION_ERROR_MESSAGES, API_RESPONSE_MESSAGES } = require("../../constants/application");
 
 const appOwner = userData[3];
 const superUser = userData[4];
@@ -65,6 +65,7 @@ describe("Application", function () {
 
   after(async function () {
     await cleanDb();
+    sinon.restore();
   });
 
   describe("GET /applications", function () {
@@ -488,4 +489,150 @@ describe("Application", function () {
         });
     });
   });
+
+  describe("PATCH /applications/:applicationId/nudge", function () {
+    let nudgeApplicationId: string;
+
+    beforeEach(async function () {
+      const applicationData = { ...applicationsData[0], userId };
+      nudgeApplicationId = await applicationModel.addApplication(applicationData);
+    });
+
+    afterEach(async function () {
+      sinon.restore();
+    });
+
+    it("should successfully nudge a pending application when user owns it and no previous nudge exists", function (done) {
+      chai
+        .request(app)
+        .patch(`/applications/${nudgeApplicationId}/nudge`)
+        .set("cookie", `${cookieName}=${jwt}`)
+        .end(function (err, res) {
+          if (err) return done(err);
+
+          expect(res).to.have.status(200);
+          expect(res.body.message).to.be.equal(API_RESPONSE_MESSAGES.NUDGE_SUCCESS);
+          expect(res.body.nudgeCount).to.be.equal(1);
+          expect(res.body.lastNudgeAt).to.be.a("string");
+          done();
+        });
+    });
+
+    it("should successfully nudge an application when 24 hours have passed since last nudge", function (done) {
+      chai
+        .request(app)
+        .patch(`/applications/${nudgeApplicationId}/nudge`)
+        .set("cookie", `${cookieName}=${jwt}`)
+        .end(function (err, res) {
+          if (err) return done(err);
+
+          expect(res).to.have.status(200);
+          expect(res.body.nudgeCount).to.be.equal(1);
+
+          const twentyFiveHoursAgo = new Date(Date.now() - 25 * 60 * 60 * 1000).toISOString();
+          applicationModel.updateApplication({ lastNudgeAt: twentyFiveHoursAgo }, nudgeApplicationId).then(() => {
+            chai
+              .request(app)
+              .patch(`/applications/${nudgeApplicationId}/nudge`)
+              .set("cookie", `${cookieName}=${jwt}`)
+              .end(function (err, res) {
+                if (err) return done(err);
+
+                expect(res).to.have.status(200);
+                expect(res.body.message).to.be.equal(API_RESPONSE_MESSAGES.NUDGE_SUCCESS);
+                expect(res.body.nudgeCount).to.be.equal(2);
+                expect(res.body.lastNudgeAt).to.be.a("string");
+                done();
+              });
+          });
+        });
+    });
+
+    it("should return 404 if the application doesn't exist", function (done) {
+      chai
+        .request(app)
+        .patch(`/applications/non-existent-id/nudge`)
+        .set("cookie", `${cookieName}=${jwt}`)
+        .end(function (err, res) {
+          if (err) return done(err);
+
+          expect(res).to.have.status(404);
+          expect(res.body.error).to.be.equal("Not Found");
+          expect(res.body.message).to.be.equal("Application not found");
+          done();
+        });
+    });
+
+    it("should return 401 if user is not authenticated", function (done) {
+      chai
+        .request(app)
+        .patch(`/applications/${nudgeApplicationId}/nudge`)
+        .end(function (err, res) {
+          if (err) return done(err);
+
+          expect(res).to.have.status(401);
+          expect(res.body.error).to.be.equal("Unauthorized");
+          expect(res.body.message).to.be.equal("Unauthenticated User");
+          done();
+        });
+    });
+
+    it("should return 401 if user does not own the application", function (done) {
+      chai
+        .request(app)
+        .patch(`/applications/${nudgeApplicationId}/nudge`)
+        .set("cookie", `${cookieName}=${secondUserJwt}`)
+        .end(function (err, res) {
+          if (err) return done(err);
+
+          expect(res).to.have.status(401);
+          expect(res.body.error).to.be.equal("Unauthorized");
+          expect(res.body.message).to.be.equal("You are not authorized to nudge this application");
+          done();
+        });
+    });
+
+    it("should return 429 when trying to nudge within 24 hours", function (done) {
+      chai
+        .request(app)
+        .patch(`/applications/${nudgeApplicationId}/nudge`)
+        .set("cookie", `${cookieName}=${jwt}`)
+        .end(function (err, res) {
+          if (err) return done(err);
+
+          expect(res).to.have.status(200);
+
+          chai
+            .request(app)
+            .patch(`/applications/${nudgeApplicationId}/nudge`)
+            .set("cookie", `${cookieName}=${jwt}`)
+            .end(function (err, res) {
+              if (err) return done(err);
+
+              expect(res).to.have.status(429);
+              expect(res.body.error).to.be.equal("Too Many Requests");
+              expect(res.body.message).to.be.equal(APPLICATION_ERROR_MESSAGES.NUDGE_TOO_SOON);
+              done();
+            });
+        });
+    });
+
+    it("should return 400 when trying to nudge an application that is not in pending status", function (done) {
+      const nonPendingApplicationData = { ...applicationsData[1], userId };
+      applicationModel.addApplication(nonPendingApplicationData).then((nonPendingApplicationId: string) => {
+        chai
+          .request(app)
+          .patch(`/applications/${nonPendingApplicationId}/nudge`)
+          .set("cookie", `${cookieName}=${jwt}`)
+          .end(function (err, res) {
+            if (err) return done(err);
+
+            expect(res).to.have.status(400);
+            expect(res.body.error).to.be.equal("Bad Request");
+            expect(res.body.message).to.be.equal(APPLICATION_ERROR_MESSAGES.NUDGE_ONLY_PENDING_ALLOWED);
+            done();
+          });
+      });
+    });
+  });
 });