new password reset process for the mobile app

src/auth-service/controllers/user.controller.js

@@ -1664,6 +1664,85 @@ const createUser = {
       return;
     }
   },
+  resetPasswordRequest: async (req, res, next) => {
+    try {
+      const errors = extractErrorsFromRequest(req);
+      if (errors) {
+        next(
+          new HttpError("bad request errors", httpStatus.BAD_REQUEST, errors)
+        );
+        return;
+      }
+      const { email } = req.body;
+      const tenant = req.query.tenant;
+      const token = userUtil.generateNumericToken(5);
+      const result = await userUtil.initiatePasswordReset(
+        {
+          email,
+          token,
+          tenant,
+        },
+        next
+      );
+
+      res
+        .status(httpStatus.OK)
+        .json({ success: true, message: result.message });
+    } catch (error) {
+      logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+      next(
+        new HttpError(
+          "Internal Server Error",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+      return;
+    }
+  },
+  resetPassword: async (req, res, next) => {
+    try {
+      const errors = extractErrorsFromRequest(req);
+      if (errors) {
+        next(
+          new HttpError("bad request errors", httpStatus.BAD_REQUEST, errors)
+        );
+        return;
+      }
+      const { token } = req.params;
+      const { password } = req.body;
+
+      const defaultTenant = constants.DEFAULT_TENANT || "airqo";
+      const tenant = isEmpty(req.query.tenant)
+        ? defaultTenant
+        : req.query.tenant;
+
+      const result = await userUtil.resetPassword(
+        {
+          token,
+          password,
+          tenant,
+        },
+        next
+      );
+
+      res
+        .status(httpStatus.OK)
+        .json({ success: true, message: result.message });
+    } catch (error) {
+      logObject("error in controller", error);
+      logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+      next(
+        new HttpError(
+          "Internal Server Error",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+      return;
+    }
+  },
+
   subscribeToNewsLetter: async (req, res, next) => {
     try {
       const errors = extractErrorsFromRequest(req);

src/auth-service/routes/v2/users.routes.js

@@ -203,6 +203,18 @@ router.post(
   createUserController.forgot
 );
 
+router.post(
+  "/reset-password-request",
+  userValidations.resetPasswordRequest,
+  createUserController.resetPasswordRequest
+);
+
+router.post(
+  "/reset-password/:token",
+  userValidations.resetPassword,
+  createUserController.resetPassword
+);
+
 router.put("/", userValidations.updateUser, createUserController.update);
 
 router.put(

src/auth-service/utils/common/email.msgs.js

@@ -41,6 +41,19 @@ module.exports = {
                             </tr>`;
     return constants.EMAIL_BODY({ email, content });
   },
+  mobilePasswordReset: ({ token, email }) => {
+    const content = `
+      <tr>
+        <td style="color: #344054; font-size: 16px; font-family: Inter; font-weight: 400; line-height: 24px; word-wrap: break-word;">
+          <p>You requested a password reset for your AirQo account associated with ${email}.</p>
+          <p>Use this code to finish setting up your new password:</p>
+          <h1 style="font-size: 36px; font-weight: bold; margin: 20px 0;">${token}</h1>
+          <p>This code will expire in 24 hours.</p>
+        </td>
+      </tr>
+    `;
+    return constants.EMAIL_BODY({ email, content });
+  },
   joinRequest: (firstName, lastName, email) => {
     const name = firstName + " " + lastName;
     const content = ` <tr>

src/auth-service/utils/common/mailer.js

@@ -1311,6 +1311,55 @@ const mailer = {
       );
     }
   },
+
+  sendPasswordResetEmail: async ({ email, token, tenant = "airqo" }, next) => {
+    try {
+      const checkResult = await SubscriptionModel(
+        tenant
+      ).checkNotificationStatus({ email, type: "email" });
+      if (!checkResult.success) {
+        return checkResult;
+      }
+
+      const mailOptions = {
+        from: {
+          name: constants.EMAIL_NAME,
+          address: constants.EMAIL,
+        },
+        to: email,
+        subject: `Password Reset Code: ${token}`,
+        html: msgs.mobilePasswordReset({ token, email }),
+        attachments: attachments,
+      };
+
+      let response = transporter.sendMail(mailOptions);
+      let data = await response;
+
+      if (isEmpty(data.rejected) && !isEmpty(data.accepted)) {
+        return {
+          success: true,
+          message: "Email sent successfully",
+          data,
+          status: httpStatus.OK,
+        };
+      } else {
+        next(
+          new HttpError("Email not sent", httpStatus.INTERNAL_SERVER_ERROR, {
+            emailResults: data,
+          })
+        );
+      }
+    } catch (error) {
+      logger.error(`Error sending password reset email: ${error.message}`);
+      next(
+        new HttpError(
+          "Internal Server Error",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+    }
+  },
   signInWithEmailLink: async (
     { email, token, tenant = "airqo" } = {},
     next

src/auth-service/utils/user.util.js

@@ -2041,6 +2041,110 @@ const createUserModule = {
       );
     }
   },
+  generateNumericToken: (length) => {
+    let token = "";
+    for (let i = 0; i < length; i++) {
+      token += Math.floor(Math.random() * 10); // Generates a random digit (0-9)
+    }
+    return token;
+  },
+  initiatePasswordReset: async ({ email, token, tenant }, next) => {
+    try {
+      const update = {
+        resetPasswordToken: token,
+        resetPasswordExpires: Date.now() + 3600000,
+      };
+      const responseFromModifyUser = await UserModel(tenant)
+        .findOneAndUpdate({ email }, update, { new: true })
+        .select("firstName lastName email");
+
+      if (isEmpty(responseFromModifyUser)) {
+        next(
+          new HttpError("Bad Request Error", httpStatus.INTERNAL_SERVER_ERROR, {
+            message: "user does not exist, please crosscheck",
+          })
+        );
+      }
+
+      await mailer.sendPasswordResetEmail({ email, token, tenant });
+
+      return {
+        success: true,
+        message: "Password reset email sent successfully",
+      };
+    } catch (error) {
+      logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+      next(
+        new HttpError(
+          "Unable to initiate password reset",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+    }
+  },
+
+  resetPassword: async ({ token, password, tenant }, next) => {
+    try {
+      const resetPasswordToken = token;
+      const timeZone = moment.tz.guess();
+      const filter = {
+        resetPasswordToken,
+        resetPasswordExpires: {
+          $gt: moment().tz(timeZone).toDate(),
+        },
+      };
+
+      const user = await UserModel(tenant).findOne(filter);
+      if (!user) {
+        throw new HttpError(
+          "Password reset token is invalid or has expired.",
+          httpStatus.BAD_REQUEST
+        );
+      }
+      const update = {
+        resetPasswordToken: null,
+        resetPasswordExpires: null,
+        password,
+      };
+
+      const responseFromModifyUser = await UserModel(tenant)
+        .findOneAndUpdate({ _id: ObjectId(user._id) }, update, { new: true })
+        .select("firstName lastName email");
+
+      const { email, firstName, lastName } = responseFromModifyUser._doc;
+
+      const responseFromSendEmail = await mailer.updateForgottenPassword(
+        {
+          email,
+          firstName,
+          lastName,
+        },
+        next
+      );
+
+      logObject("responseFromSendEmail", responseFromSendEmail);
+
+      if (responseFromSendEmail.success === true) {
+        return {
+          success: true,
+          message: "Password reset successful",
+        };
+      } else if (responseFromSendEmail.success === false) {
+        return responseFromSendEmail;
+      }
+    } catch (error) {
+      logObject("error", error);
+      logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+      next(
+        new HttpError(
+          "Internal Server Error",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+    }
+  },
   generateResetToken: (next) => {
     try {
       const token = crypto.randomBytes(20).toString("hex");

src/auth-service/validators/users.validators.js

@@ -842,6 +842,46 @@ const getUser = [
   ],
 ];
 
+const resetPasswordRequest = [
+  body("email")
+    .exists()
+    .withMessage("Email is required")
+    .isEmail()
+    .withMessage("Invalid email format")
+    .trim(),
+  //Potentially add tenant validation here as well, using the oneOf approach if necessary
+];
+
+const resetPassword = [
+  param("token")
+    .exists()
+    .withMessage("Token is required")
+    .bail()
+    .isNumeric()
+    .withMessage("Token must be numeric")
+    .isLength({ min: 5, max: 5 })
+    .withMessage("Token must be 5 digits")
+    .trim(),
+  body("password")
+    .exists()
+    .withMessage("Password is required")
+    .bail()
+    .isLength({ min: 6 })
+    .withMessage("Password must be at least 6 characters long")
+    .trim(),
+  body("confirmPassword")
+    .exists()
+    .withMessage("Confirm Password is required")
+    .bail()
+    .custom((value, { req }) => {
+      if (value !== req.body.password) {
+        throw new Error("Passwords do not match");
+      }
+      return true;
+    })
+    .trim(),
+];
+
 module.exports = {
   tenant: validateTenant,
   AirqoTenantOnly: validateAirqoTenantOnly,
@@ -876,4 +916,6 @@ module.exports = {
   unSubscribeFromNotifications,
   notificationStatus,
   getUser,
+  resetPasswordRequest,
+  resetPassword,
 };