resolve: merge conflict

Author: Achintya-Chatterjee

config/custom-environment-variables.cjs

@@ -90,6 +90,10 @@ module.exports = {
       __name: "USER_TOKEN_REFRESH_TTL",
       __format: "number",
     },
+    impersonationTtl: {
+      __name: "USER_TOKEN_IMPERSONATION_TTL",
+      __format: "number",
+    },
     publicKey: "PUBLIC_KEY",
     privateKey: "PRIVATE_KEY",
   },
@@ -98,6 +102,10 @@ module.exports = {
     botPublicKey: "BOT_PUBLIC_KEY",
   },
 
+  discordService: {
+    publicKey: "DISCORD_SERVICE_PUBLIC_KEY",
+  },
+
   cronJobHandler: {
     publicKey: "CRON_JOB_PUBLIC_KEY",
   },

config/default.cjs

@@ -88,6 +88,7 @@ module.exports = {
     cookieV2Name: `rds-session-v2-${NODE_ENV}`,
     ttl: 30 * 24 * 60 * 60, // in seconds
     refreshTtl: 180 * 24 * 60 * 60, // in seconds
+    impersonationTtl: 15 * 60, // in seconds
     publicKey: "<publicKey>",
     privateKey: "<privateKey>",
   },
@@ -96,6 +97,10 @@ module.exports = {
     botPublicKey: "<botpublicKey>",
   },
 
+  discordService: {
+    publicKey: "DISCORD_SERVICE_PUBLIC_KEY",
+  },
+
   // Cloudinary keys
   cloudinary: {
     cloud_name: "Cloud_name",

constants/bot.ts

@@ -1,10 +1,15 @@
-const CLOUDFLARE_WORKER = "Cloudflare Worker";
-const BAD_TOKEN = "BAD.JWT.TOKEN";
-const CRON_JOB_HANDLER = "Cron Job Handler";
+export const CLOUDFLARE_WORKER = "Cloudflare Worker";
+export const BAD_TOKEN = "BAD.JWT.TOKEN";
+export const CRON_JOB_HANDLER = "Cron Job Handler";
+export const DISCORD_SERVICE = "Discord Service";
 
-const Services = {
+export const Services = {
   CLOUDFLARE_WORKER: CLOUDFLARE_WORKER,
   CRON_JOB_HANDLER: CRON_JOB_HANDLER,
 };
 
-export { CLOUDFLARE_WORKER, BAD_TOKEN, CRON_JOB_HANDLER, Services };
+export const DiscordServiceHeader = {
+  name: "x-service-name"
+}
+
+export default { CLOUDFLARE_WORKER, BAD_TOKEN, CRON_JOB_HANDLER, Services, DISCORD_SERVICE, DiscordServiceHeader };

constants/requests.ts

@@ -39,7 +39,9 @@ export const REQUEST_ALREADY_REJECTED = "Request already rejected";
 export const ERROR_WHILE_FETCHING_REQUEST = "Error while fetching request";
 export const ERROR_WHILE_CREATING_REQUEST = "Error while creating request";
 export const ERROR_WHILE_UPDATING_REQUEST = "Error while updating request";
+export const ERROR_WHILE_ACKNOWLEDGING_REQUEST = "Error while acknowledging request";
 
+export const REQUEST_ID_REQUIRED = "Request id is required";
 export const REQUEST_DOES_NOT_EXIST = "Request does not exist";
 export const REQUEST_ALREADY_PENDING = "Request already exists please wait for approval or rejection";
 export const UNAUTHORIZED_TO_CREATE_OOO_REQUEST = "Unauthorized to create OOO request";
@@ -68,3 +70,14 @@ export const INVALID_REQUEST_TYPE = "Invalid request type";
 export const INVALID_REQUEST_DEADLINE = "New deadline of the request must be greater than old deadline";
 export const REQUEST_UPDATED_SUCCESSFULLY = "Request updated successfully";
 export const UNAUTHORIZED_TO_UPDATE_REQUEST = "Unauthorized to update request";
+
+export const FEATURE_NOT_IMPLEMENTED = "Feature not implemented";
+
+export const INVALID_ACTION_PARAM = "Invalid 'action' parameter: must be either 'START' or 'STOP'";
+
+export const OPERATION_NOT_ALLOWED = "You are not allowed for this operation at the moment";
+
+export const IMPERSONATION_LOG_TYPE = {
+  SESSION_STARTED:"SESSION_STARTED",
+  SESSION_STOPPED:"SESSION_STOPPED"
+}

controllers/impersonationRequests.ts

@@ -0,0 +1,229 @@
+import {
+  ERROR_WHILE_CREATING_REQUEST,
+  ERROR_WHILE_FETCHING_REQUEST,
+  REQUEST_FETCHED_SUCCESSFULLY,
+  REQUEST_DOES_NOT_EXIST,
+  ERROR_WHILE_UPDATING_REQUEST,
+  REQUEST_CREATED_SUCCESSFULLY,
+  OPERATION_NOT_ALLOWED
+} from "../constants/requests";
+import { createImpersonationRequestService, updateImpersonationRequestService, generateImpersonationTokenService, startImpersonationService, stopImpersonationService } from "../services/impersonationRequests";
+import { getImpersonationRequestById, getImpersonationRequests } from "../models/impersonationRequests";
+import {
+  CreateImpersonationRequest,
+  CreateImpersonationRequestBody,
+  UpdateImpersonationRequest,
+  UpdateImpersonationRequestStatusBody,
+  ImpersonationRequestResponse,
+  GetImpersonationControllerRequest,
+  GetImpersonationRequestByIdRequest,
+  ImpersonationSessionRequest
+} from "../types/impersonationRequest";
+import { getPaginatedLink } from "../utils/helper";
+import { NextFunction } from "express";
+import logger from "../utils/logger";
+
+/**
+ * Controller to handle creation of an impersonation request.
+ *
+ * @param {CreateImpersonationRequest} req - Express request object with user and body data.
+ * @param {ImpersonationRequestResponse} res - Express response object.
+ * @param {NextFunction} next - Express next middleware function.
+ * @returns {Promise<ImpersonationRequestResponse | void>} Returns the created request or passes error to next middleware.
+ */
+export const createImpersonationRequestController = async (
+  req: CreateImpersonationRequest,
+  res: ImpersonationRequestResponse,
+  next: NextFunction
+): Promise<ImpersonationRequestResponse | void> => {
+  try {
+    const { createdFor, reason } = req.body as CreateImpersonationRequestBody;
+    const userId = req.userData?.id;
+
+    const impersonationRequest = await createImpersonationRequestService({
+      createdBy: userId,
+      createdFor,
+      reason
+    });
+
+    return res.status(201).json({
+      message: REQUEST_CREATED_SUCCESSFULLY,
+      data: {
+        ...impersonationRequest
+      }
+    });
+  } catch (error) {
+    logger.error(ERROR_WHILE_CREATING_REQUEST, error);
+    next(error);
+  }
+};
+
+/**
+ * Controller to fetch an impersonation request by its ID.
+ *
+ * @param {GetImpersonationRequestByIdRequest} req - Express request object containing `id` parameter.
+ * @param {ImpersonationRequestResponse} res - Express response object.
+ * @returns {Promise<ImpersonationRequestResponse>} Returns the request if found, or 404 if it doesn't exist.
+ */
+export const getImpersonationRequestByIdController = async (
+  req: GetImpersonationRequestByIdRequest,
+  res: ImpersonationRequestResponse
+): Promise<ImpersonationRequestResponse> => {
+  const id = req.params.id;
+  try {
+    const request = await getImpersonationRequestById(id);
+
+    if (!request) {
+      return res.status(404).json({
+        message: REQUEST_DOES_NOT_EXIST,
+      });
+    }
+
+    return res.status(200).json({
+      message: REQUEST_FETCHED_SUCCESSFULLY,
+      data: request,
+    });
+
+  } catch (error) {
+    logger.error(ERROR_WHILE_FETCHING_REQUEST, error);
+    return res.boom.badImplementation(ERROR_WHILE_FETCHING_REQUEST);
+  }
+};
+
+/**
+ * Controller to fetch impersonation requests with optional filtering and pagination.
+ *
+ * @param {GetImpersonationControllerRequest} req - Express request object containing query parameters.
+ * @param {ImpersonationRequestResponse} res - Express response object.
+ * @returns {Promise<ImpersonationRequestResponse>} Returns paginated impersonation request data or 204 if none found.
+ */
+export const getImpersonationRequestsController = async (
+  req: GetImpersonationControllerRequest,
+  res: ImpersonationRequestResponse
+): Promise<ImpersonationRequestResponse> => {
+  try {
+    const { query } = req;
+
+    const requests = await getImpersonationRequests(query);
+    if (!requests || requests.allRequests.length === 0) {
+      return res.status(204).send();
+    }
+
+    const { allRequests, next, prev } = requests;
+    const count = allRequests.length;
+
+    let nextUrl = null;
+    let prevUrl = null;
+    if (next) {
+      nextUrl = getPaginatedLink({
+        endpoint: "/impersonation/requests",
+        query,
+        cursorKey: "next",
+        docId: next,
+      });
+    }
+    if (prev) {
+      prevUrl = getPaginatedLink({
+        endpoint: "/impersonation/requests",
+        query,
+        cursorKey: "prev",
+        docId: prev,
+      });
+    }
+
+    return res.status(200).json({
+      message: REQUEST_FETCHED_SUCCESSFULLY,
+      data: allRequests,
+      next: nextUrl,
+      prev: prevUrl,
+      count,
+    });
+  } catch (err) {
+    logger.error(ERROR_WHILE_FETCHING_REQUEST, err);
+    return res.boom.badImplementation(ERROR_WHILE_FETCHING_REQUEST);
+  }
+};
+
+
+/**
+ * Controller to  Update the status of an impersonation request.
+ *
+ * @param {UpdateImpersonationRequest} req - Express request with params, body, and user data.
+ * @param {ImpersonationRequestResponse} res - Express response object.
+ * @param {NextFunction} next - Express middleware `next` function.
+ * @returns {Promise<ImpersonationRequestResponse>} Returns updated request data or passes error to `next`.
+ */
+export const updateImpersonationRequestStatusController = async (
+  req: UpdateImpersonationRequest,
+  res: ImpersonationRequestResponse,
+  next: NextFunction
+): Promise<ImpersonationRequestResponse> => {
+  try {
+    const requestId = req.params.id;
+    const lastModifiedBy = req.userData.id;
+    const requestBody: UpdateImpersonationRequestStatusBody = req.body;
+    
+    const { returnMessage, updatedRequest: response } = await updateImpersonationRequestService({
+      id: requestId,
+      updatePayload: requestBody,
+      lastModifiedBy,
+    });
+
+    return res.status(200).json({
+      message: returnMessage,
+      data: {
+        ...response,
+      },
+    });
+  } catch (error) {
+    logger.error(ERROR_WHILE_UPDATING_REQUEST, error);
+    next(error);
+  }
+};
+
+
+
+/**
+ * Controller to handle impersonation session actions (START or STOP).
+ *
+ * @param {ImpersonationSessionRequest} req - Express request object containing user data, query params, and impersonation flag.
+ * @param {ImpersonationRequestResponse} res - Express response object used to send the response.
+ * @param {NextFunction} next - Express next middleware function for error handling.
+ * @returns {Promise<ImpersonationRequestResponse>} Sends a JSON response with updated request data and sets authentication cookies based on action.
+ *
+ * @throws {Forbidden} If the action is invalid or STOP is requested without an active impersonation session.
+ */
+export const impersonationController = async (
+  req: ImpersonationSessionRequest,
+  res: ImpersonationRequestResponse,
+  next: NextFunction
+): Promise<ImpersonationRequestResponse | void> => {
+  const { action } = req.query;
+  const requestId = req.params.id;
+  const userId = req.userData?.id;
+  let authCookie;
+  let response;
+  try {
+
+    if (action === "START") {
+      authCookie = await generateImpersonationTokenService(requestId, action);
+      response = await startImpersonationService({ requestId, userId });
+    }
+
+    if (action === "STOP") {
+      authCookie = await generateImpersonationTokenService(requestId, action);
+      response = await stopImpersonationService({ requestId, userId });
+    }
+
+    res.clearCookie(authCookie.name);
+    res.cookie(authCookie.name, authCookie.value, authCookie.options);
+
+    return res.status(200).json({
+      message: response.returnMessage,
+      data: response.updatedRequest
+    });
+  } catch (error) {
+    logger.error(`Failed to process impersonation ${action} for requestId=${requestId}, userId=${userId}`, error);
+    return next(error);
+  }
+};

controllers/oooRequests.ts

@@ -66,9 +66,9 @@ export const createOooRequestController = async (
     }
 
     const latestOooRequest: OooStatusRequest = await getRequestByKeyValues({
-        userId,
-        type: REQUEST_TYPE.OOO,
-        status: REQUEST_STATE.PENDING,
+      requestedBy: userId,
+      type: REQUEST_TYPE.OOO,
+      status: REQUEST_STATE.PENDING,
     });
 
     if (latestOooRequest) {
@@ -79,7 +79,7 @@ export const createOooRequestController = async (
         return res.boom.conflict(REQUEST_ALREADY_PENDING);
     }
 
-    await createOooRequest(requestBody, username, userId);
+    await createOooRequest(requestBody, userId);
 
     return res.status(201).json({
       message: REQUEST_CREATED_SUCCESSFULLY,
@@ -149,3 +149,35 @@ export const updateOooRequestController = async (req: UpdateRequest, res: Custom
     return res.boom.badImplementation(ERROR_WHILE_UPDATING_REQUEST);
   }
 };
+/**
+ * Acknowledges an Out-of-Office (OOO) request by updating its status to approved or rejected
+ * 
+ * @param {AcknowledgeOooRequest} req - The request object containing acknowledgment details (status, comment) and request ID in params
+ * @param {OooRequestResponse} res - The response object for sending success/error responses
+ * @param {NextFunction} next - Express next function for error handling
+ * @returns {Promise<OooRequestResponse>} Resolves with success message or passes error to next middleware
+ */
+export const acknowledgeOooRequestController = async (
+  req: AcknowledgeOooRequest,
+  res: OooRequestResponse,
+  next: NextFunction
+)
+  : Promise<OooRequestResponse> => {
+    try {
+
+      const requestBody = req.body;
+      const superUserId = req.userData.id;
+      const requestId = req.params.id;
+
+      const response = await acknowledgeOooRequestService(requestId, requestBody, superUserId);
+
+      return res.status(200).json({
+        message: response.message,
+      });
+    }
+    catch(error){
+      logger.error(ERROR_WHILE_ACKNOWLEDGING_REQUEST, error);
+      next(error);
+      return;
+  }
+};

controllers/requests.ts

@@ -121,9 +121,12 @@ export const getRequestsController = async (req: any, res: any) => {
  * @param {CustomResponse} res - The response object.
  * @returns {Promise<void>} Resolves or sends an error for invalid types.
  */
-export const updateRequestBeforeAcknowledgedController = async (req: Request, res: CustomResponse) => {
+export const updateRequestBeforeAcknowledgedController = async (req: Request, res: CustomResponse, next: NextFunction) => {
   const type = req.body.type;
   switch(type){
+    case REQUEST_TYPE.OOO:
+      await acknowledgeOooRequestController(req as AcknowledgeOooRequest, res as OooRequestResponse, next);
+      break;
     case REQUEST_TYPE.ONBOARDING:
       await updateOnboardingExtensionRequestController(req as UpdateOnboardingExtensionRequest, res as OnboardingExtensionResponse);
       break;