Add api to create onboarding extension request from discord server

constants/requests.ts

@@ -15,6 +15,7 @@ export const REQUEST_TYPE = {
   EXTENSION: "EXTENSION",
   TASK: "TASK",
   ALL: "ALL",
+  ONBOARDING: "ONBOARDING",
 };
 
 export const REQUEST_LOG_TYPE = {

controllers/onboardingExtension.ts

@@ -0,0 +1,111 @@
+import {
+  ERROR_WHILE_CREATING_REQUEST,
+  LOG_ACTION,
+  REQUEST_ALREADY_PENDING,
+  REQUEST_LOG_TYPE,
+  REQUEST_STATE,
+  REQUEST_TYPE,
+} from "../constants/requests";
+import { userState } from "../constants/userStatus";
+import { addLog } from "../models/logs";
+import { createRequest, getRequestByKeyValues } from "../models/requests";
+import { fetchUser } from "../models/users";
+import { getUserStatus } from "../models/userStatus";
+import { User } from "../typeDefinitions/users";
+import { OnboardingExtension, OnboardingExtensionCreateRequest, OnboardingExtensionResponse } from "../types/onboardingExtension";
+
+export const createOnboardingExtensionRequestController = async (req: OnboardingExtensionCreateRequest, res: OnboardingExtensionResponse) => {
+  try {
+
+    const data = req.body;
+    const {user, userExists} = await fetchUser({discordId: data.userId});
+
+    if(!userExists) {
+      return res.boom.notFound("User not found");
+    }
+
+    const { id: userId, discordId: userDiscordId, discordJoinedAt, username} = user as User;
+    const { data: userStatus } =  await getUserStatus(userId);
+
+    if(!userStatus || userStatus.currentStatus.state != userState.ONBOARDING){
+      return res.boom.badRequest("User does not have onboarding status");
+    }
+
+    const requestedUserResponse = await fetchUser({discordId: data.requestedBy});
+
+    if(!requestedUserResponse.userExists) {
+      return res.boom.notFound("User not found");
+    }
+
+    const {roles, discordId: requestedUserDiscordId} = requestedUserResponse.user as User;
+
+    if(!(roles?.super_user || (requestedUserDiscordId === userDiscordId))){
+      return res.boom.unauthorized("Only super user and onboarding user are authorized to create an onboarding extension request");
+    }
+
+    const latestExtensionRequest: OnboardingExtension = await getRequestByKeyValues({
+        userId: userId,
+        type: REQUEST_TYPE.ONBOARDING
+    });
+
+    if(latestExtensionRequest && latestExtensionRequest.state === REQUEST_STATE.PENDING){
+      return res.boom.badRequest(REQUEST_ALREADY_PENDING);
+    }
+
+    const thirtyOneDaysInMillisecond = 31*24*60*60*1000;
+    const discordJoinedDateInMillisecond = new Date(discordJoinedAt).getTime();
+    const numberOfDaysInMillisecond = Math.floor(data.numberOfDays)*24*60*60*1000;
+
+    let requestNumber: number;
+    let oldEndsOn: number;
+    let newEndsOn: number;
+
+    if(!latestExtensionRequest){
+      requestNumber = 1;
+      oldEndsOn = discordJoinedDateInMillisecond + thirtyOneDaysInMillisecond;
+    }else if(latestExtensionRequest.state === REQUEST_STATE.REJECTED) {
+      requestNumber = latestExtensionRequest.requestNumber + 1;
+      oldEndsOn = latestExtensionRequest.oldEndsOn;
+    }else{
+      requestNumber = latestExtensionRequest.requestNumber + 1;
+      oldEndsOn = latestExtensionRequest.newEndsOn;
+    }
+
+    newEndsOn = oldEndsOn + numberOfDaysInMillisecond;
+
+    const onboardingExtension = await createRequest({
+      type: REQUEST_TYPE.ONBOARDING,
+      state: REQUEST_STATE.PENDING,
+      userId: userId,
+      requestedBy: username,
+      oldEndsOn: oldEndsOn,
+      newEndsOn: newEndsOn,
+      reason: data.reason,
+      requestNumber: requestNumber,
+    });
+
+    const onboardingExtensionLog = {
+      type: REQUEST_LOG_TYPE.REQUEST_CREATED,
+      meta: {
+        requestId: onboardingExtension.id,
+        action: LOG_ACTION.CREATE,
+        userId: userId,
+        createdAt: Date.now(),
+      },
+      body: onboardingExtension,
+    };
+
+    await addLog(onboardingExtensionLog.type, onboardingExtensionLog.meta, onboardingExtensionLog.body);
+
+    return res.status(201).json({
+      message: "Onboarding extension request created successfully!",  
+      data: {
+        id: onboardingExtension.id,
+        ...onboardingExtension,
+      }
+    });
+  }catch (err) {
+    logger.error(ERROR_WHILE_CREATING_REQUEST, err);
+    return res.boom.badImplementation(ERROR_WHILE_CREATING_REQUEST);
+  }
+};

controllers/requests.ts

@@ -13,9 +13,11 @@ import { createTaskExtensionRequest, updateTaskExtensionRequest } from "./extens
 import { UpdateRequest } from "../types/requests";
 import { TaskRequestRequest } from "../types/taskRequests";
 import { createTaskRequestController } from "./taskRequestsv2";
+import { OnboardingExtensionCreateRequest, OnboardingExtensionResponse } from "../types/onboardingExtension";
+import { createOnboardingExtensionRequestController } from "./onboardingExtension";
 
 export const createRequestController = async (
-  req: OooRequestCreateRequest | ExtensionRequestRequest | TaskRequestRequest,
+  req: OooRequestCreateRequest | ExtensionRequestRequest | TaskRequestRequest | OnboardingExtensionCreateRequest,
   res: CustomResponse
 ) => {
   const type = req.body.type;
@@ -26,6 +28,8 @@ export const createRequestController = async (
       return await createTaskExtensionRequest(req as ExtensionRequestRequest, res as ExtensionRequestResponse);
     case REQUEST_TYPE.TASK:
       return await createTaskRequestController(req as TaskRequestRequest, res as CustomResponse);
+    case REQUEST_TYPE.ONBOARDING:
+      return await createOnboardingExtensionRequestController(req as OnboardingExtensionCreateRequest, res as OnboardingExtensionResponse);
     default:
       return res.boom.badRequest("Invalid request type");
   }

middlewares/skipAuthenticateForOnboardingExtension.ts

@@ -0,0 +1,20 @@
+import { NextFunction, Request, Response } from "express"
+import { REQUEST_TYPE } from "../constants/requests";
+
+export const skipAuthenticateForOnboardingExtensionRequest = (authenticate, verifyDiscordBot) => {
+    return async (req: Request, res: Response, next: NextFunction) => {
+        const type = req.body.type;
+        const dev = req.query.dev;
+
+        if(type === REQUEST_TYPE.ONBOARDING){
+            if (dev != "true"){
+                return res.status(501).json({
+                    message: "Feature not implemented"
+                })
+            }
+            return await verifyDiscordBot(req, res, next);
+        }
+
+        return await authenticate(req, res, next)
+    }
+}

middlewares/validators/onboardingExtensionRequest.ts

@@ -0,0 +1,42 @@
+import joi from "joi";
+import { NextFunction } from "express";
+import { REQUEST_TYPE } from "../../constants/requests";
+import { OnboardingExtensionCreateRequest, OnboardingExtensionResponse } from "../../types/onboardingExtension";
+
+export const createOnboardingExtensionRequestValidator = async (
+  req: OnboardingExtensionCreateRequest,
+  _res: OnboardingExtensionResponse,
+  _next: NextFunction
+) => {
+
+  const schema = joi
+    .object()
+    .strict()
+    .keys({
+      numberOfDays: joi.number().required().positive().integer().min(1).messages({
+        "number.base": "numberOfDays must be a number",
+        "any.required": "numberOfDays is required",
+        "number.positive": "numberOfDays must be positive",
+        "number.min": "numberOfDays must be greater than zero",
+        "number.integer": "numberOfDays must be a integer"
+      }),
+      reason: joi.string().required().messages({
+        "string.empty": "reason cannot be empty",
+        "any.required": "reason is required",
+      }),
+      type: joi.string().valid(REQUEST_TYPE.ONBOARDING).required().messages({
+        "string.empty": "type cannot be empty",
+        "any.required": "type is required",
+      }),
+      requestedBy: joi.string().required().messages({
+        "string.empty": "requestedBy cannot be empty",
+        "any.required": "requestedBy is required",
+      }),
+      userId: joi.string().required().messages({
+        "string.empty": "userId cannot be empty",
+        "any.required": "userId is required"
+      })
+    });
+
+  await schema.validateAsync(req.body, { abortEarly: false });
+};

middlewares/validators/requests.ts

@@ -9,9 +9,11 @@ import { ExtensionRequestRequest, ExtensionRequestResponse } from "../../types/e
 import { CustomResponse } from "../../typeDefinitions/global";
 import { UpdateRequest } from "../../types/requests";
 import { TaskRequestRequest, TaskRequestResponse } from "../../types/taskRequests";
+import { createOnboardingExtensionRequestValidator } from "./onboardingExtensionRequest";
+import { OnboardingExtensionCreateRequest, OnboardingExtensionResponse } from "../../types/onboardingExtension";
 
 export const createRequestsMiddleware = async (
-  req: OooRequestCreateRequest|ExtensionRequestRequest | TaskRequestRequest,
+  req: OooRequestCreateRequest|ExtensionRequestRequest | TaskRequestRequest | OnboardingExtensionCreateRequest,
   res: CustomResponse,
   next: NextFunction
 ) => {
@@ -28,6 +30,9 @@ export const createRequestsMiddleware = async (
       case REQUEST_TYPE.TASK:
         await createTaskRequestValidator(req as TaskRequestRequest, res as TaskRequestResponse, next);
         break;
+      case REQUEST_TYPE.ONBOARDING:
+        await createOnboardingExtensionRequestValidator(req as OnboardingExtensionCreateRequest, res as OnboardingExtensionResponse, next);
+        break;
       default:
         res.boom.badRequest(`Invalid request type: ${type}`);
     }
@@ -36,7 +41,7 @@ export const createRequestsMiddleware = async (
   } catch (error) {
     const errorMessages = error.details.map((detail:any) => detail.message);
     logger.error(`Error while validating request payload : ${errorMessages}`);
-    res.boom.badRequest(errorMessages);
+    return res.boom.badRequest(errorMessages);
   }
 };
 

routes/requests.ts

@@ -6,8 +6,10 @@ const { SUPERUSER } = require("../constants/roles");
 import authenticate from "../middlewares/authenticate";
 import { createRequestsMiddleware,updateRequestsMiddleware,getRequestsMiddleware } from "../middlewares/validators/requests";
 import { createRequestController , updateRequestController, getRequestsController} from "../controllers/requests";
+import { skipAuthenticateForOnboardingExtensionRequest } from "../middlewares/skipAuthenticateForOnboardingExtension";
+import { verifyDiscordBot } from "../middlewares/authorizeBot";
 
 router.get("/", getRequestsMiddleware, getRequestsController);
-router.post("/",authenticate, createRequestsMiddleware, createRequestController);
+router.post("/", skipAuthenticateForOnboardingExtensionRequest(authenticate, verifyDiscordBot), createRequestsMiddleware, createRequestController);
 router.put("/:id",authenticate, authorizeRoles([SUPERUSER]), updateRequestsMiddleware, updateRequestController);
 module.exports = router;