Merge pull request #1878 from Real-Dev-Squad/develop

Dev to main sync

Author: iamitprakash

constants/oooRequest.ts

@@ -0,0 +1,20 @@
+export const OOO_REQUEST_ALREADY_PENDING =
+    "You already have a pending request. Please wait for it to be approved or rejected.";
+export const ERROR_WHILE_CREATING_OOO_REQUEST = "Error while creating OOO request";
+export const ERROR_WHILE_UPDATING_OOO_REQUEST = "Error while updating OOO request";
+export const OOO_STATUS_REQUEST_CREATED_SUCCESSFULLY = "OOO status requested successfully";
+export const OOO_STATUS_REQUEST_UPDATED_SUCCESSFULLY = "OOO status request updated successfully";
+
+export const OOO_LOG_TYPE = {
+    OOO_REQUEST_CREATED: "OOO_REQUEST_CREATED",
+    OOO_REQUEST_APPROVED: "OOO_REQUEST_APPROVED",
+    OOO_REQUEST_REJECTED: "OOO_REQUEST_REJECTED",
+    OOO_REQUEST_BLOCKED: "OOO_REQUEST_BLOCKED",
+    OOO_REQUEST_CANCELLED: "OOO_REQUEST_CANCELLED",
+};
+
+export const LOG_ACTION={
+    CREATE:"create",
+    ERRORS:"errors",
+    UPDATE:"update",
+}

constants/request.ts

@@ -1,5 +1,9 @@
 export const REQUEST_STATE = {
-    APPROVED: "APPROVED",
-    PENDING: "PENDING",
-    REJECTED: "REJECTED",
-  };
+  APPROVED: "APPROVED",
+  PENDING: "PENDING",
+  REJECTED: "REJECTED",
+};
+
+export const REQUEST_TYPE = {
+  OOO: "OOO",
+};

constants/tasks.ts

@@ -21,6 +21,7 @@ const TASK_STATUS = {
   VERIFIED: "VERIFIED",
   DONE: "DONE",
   OVERDUE: "OVERDUE",
+  BACKLOG: "BACKLOG",
 };
 
 // TODO: convert this to new task status

controllers/oooRequests.ts

@@ -0,0 +1,105 @@
+import { createOooRequest, updateOooRequest } from "../models/oooRequests";
+import { OooRequestCreateRequest, OooRequestResponse, OooRequestUpdateRequest } from "../types/oooRequest";
+import { addLog } from "../models/logs";
+import {
+    ERROR_WHILE_CREATING_OOO_REQUEST,
+    ERROR_WHILE_UPDATING_OOO_REQUEST,
+    LOG_ACTION,
+    OOO_LOG_TYPE,
+    OOO_STATUS_REQUEST_CREATED_SUCCESSFULLY,
+    OOO_STATUS_REQUEST_UPDATED_SUCCESSFULLY,
+} from "../constants/oooRequest";
+import { REQUEST_STATE } from "../constants/request";
+
+export const createOooRequestController = async (
+    req: OooRequestCreateRequest, res: OooRequestResponse) => {
+    const oooRequestBody = req.body;
+    const userId = req?.userData?.id;
+    if (!userId) {
+        return res.boom.unauthorized();
+    }
+
+    try {
+        const oooRequestResult = await createOooRequest({ requestedBy: userId, ...oooRequestBody });
+        if ('error' in oooRequestResult) {
+            const oooRequestLog = {
+                type: OOO_LOG_TYPE.OOO_REQUEST_BLOCKED,
+                meta: {
+                    action: LOG_ACTION.ERRORS,
+                    createdBy: userId,
+                    createdAt: Date.now(),
+                },
+                body: {
+                    error: oooRequestResult.error,
+                    ...oooRequestBody,
+                },
+            };
+            await addLog(oooRequestLog.type, oooRequestLog.meta, oooRequestLog.body);
+
+            return res.boom.badRequest(oooRequestResult.error);
+        } else {
+            const oooRequestLog = {
+                type: OOO_LOG_TYPE.OOO_REQUEST_CREATED,
+                meta: {
+                    oooRequestId: oooRequestResult.id,
+                    action: LOG_ACTION.CREATE,
+                    createdBy: userId,
+                    createdAt: Date.now(),
+                },
+                body: oooRequestResult,
+            };
+            await addLog(oooRequestLog.type, oooRequestLog.meta, oooRequestLog.body);
+            return res.status(201).json({
+                message: OOO_STATUS_REQUEST_CREATED_SUCCESSFULLY,
+                data: {
+                    id: oooRequestResult.id,
+                    ...oooRequestResult,
+                },
+            });
+        }
+    } catch (err) {
+        logger.error(ERROR_WHILE_CREATING_OOO_REQUEST, err);
+        return res.boom.badImplementation(ERROR_WHILE_CREATING_OOO_REQUEST);
+    }
+}
+
+export const updateOooRequestController = async (req: OooRequestUpdateRequest, res: OooRequestResponse) => {
+    const oooRequestBody = req.body;
+    const userId = req?.userData?.id;
+    const oooRequestId = req.params.id;
+    if (!userId) {
+        return res.boom.unauthorized();
+    }
+
+    try {
+        const oooRequestResult = await updateOooRequest(oooRequestId, oooRequestBody, userId);
+        if ('error' in oooRequestResult) {
+            return res.boom.badRequest(oooRequestResult.error);
+        }
+        if (oooRequestResult.state === REQUEST_STATE.REJECTED) {
+            return res.boom.badRequest(oooRequestResult.error);
+        } else {
+            const oooRequestLog = {
+                type: OOO_LOG_TYPE.OOO_REQUEST_APPROVED,
+                meta: {
+                    oooRequestId: oooRequestId,
+                    action: LOG_ACTION.UPDATE,
+                    createdBy: userId,
+                    createdAt: Date.now(),
+                },
+                body: oooRequestResult,
+            };
+            await addLog(oooRequestLog.type, oooRequestLog.meta, oooRequestLog.body);
+            return res.status(201).json({
+                message: OOO_STATUS_REQUEST_UPDATED_SUCCESSFULLY,
+                data: {
+                    id: oooRequestId,
+                    ...oooRequestResult,
+                },
+            });
+        }
+    } catch (err) {
+        logger.error(ERROR_WHILE_UPDATING_OOO_REQUEST, err);
+        return res.boom.badImplementation(ERROR_WHILE_UPDATING_OOO_REQUEST);
+    }
+};

controllers/requests.ts

@@ -0,0 +1,29 @@
+import { OooRequestResponse, OooRequestCreateRequest, OooRequestUpdateRequest } from "../types/oooRequest";
+import { REQUEST_TYPE } from "../constants/request";
+import { createOooRequestController, updateOooRequestController } from "./oooRequests";
+
+export const createRequestController = async (
+  req: OooRequestCreateRequest,
+  res: OooRequestResponse
+) => {
+  const type = req.body.type;
+  switch (type) {
+    case REQUEST_TYPE.OOO:
+      return await createOooRequestController(req as OooRequestCreateRequest, res as OooRequestResponse);
+    default:
+      return res.boom.badRequest("Invalid request type");
+  }
+};
+
+export const updateRequestController = async (
+  req: OooRequestUpdateRequest,
+  res: OooRequestResponse
+) => {
+  const type = req.body.type;
+  switch (type) {
+    case REQUEST_TYPE.OOO:
+      return await updateOooRequestController(req as OooRequestUpdateRequest, res as OooRequestResponse);
+    default:
+      return res.boom.badRequest("Invalid request type");
+  }
+};

controllers/tasks.js

@@ -289,18 +289,6 @@ const updateTask = async (req, res) => {
       }
     }
 
-    // currently the task is assigned to a user and the superuser is trying to un assign this task from them.
-    if (
-      requestData?.status === TASK_STATUS.AVAILABLE &&
-      task.taskData.status !== TASK_STATUS.AVAILABLE &&
-      Object.keys(req.body).length === 1
-    ) {
-      requestData.assignee = null;
-      requestData.percentCompleted = 0;
-      requestData.startedOn = null;
-      requestData.endsOn = null;
-    }
-
     await tasks.updateTask(requestData, req.params.id);
     if (requestData.assignee) {
       // New Assignee Status Update
@@ -334,38 +322,40 @@ const updateTaskStatus = async (req, res, next) => {
     let userStatusUpdate;
     const taskId = req.params.id;
     const { userStatusFlag } = req.query;
+    const status = req.body?.status;
     const { id: userId, username } = req.userData;
     const task = await tasks.fetchSelfTask(taskId, userId);
 
     if (task.taskNotFound) return res.boom.notFound("Task doesn't exist");
     if (task.notAssignedToYou) return res.boom.forbidden("This task is not assigned to you");
-    if (task.taskData.status === TASK_STATUS.VERIFIED || req.body.status === TASK_STATUS.MERGED)
+    if (
+      task.taskData.status === TASK_STATUS.VERIFIED ||
+      status === TASK_STATUS.MERGED ||
+      status === TASK_STATUS.BACKLOG
+    )
       return res.boom.forbidden("Status cannot be updated. Please contact admin.");
 
     if (userStatusFlag) {
       if (task.taskData.status === TASK_STATUS.DONE && req.body.percentCompleted < 100) {
-        if (req.body.status === TASK_STATUS.DONE || !req.body.status) {
+        if (status === TASK_STATUS.DONE || !status) {
           return res.boom.badRequest("Task percentCompleted can't updated as status is DONE");
         }
       }
 
-      if (
-        (req.body.status === TASK_STATUS.DONE || req.body.status === TASK_STATUS.VERIFIED) &&
-        task.taskData.percentCompleted !== 100
-      ) {
+      if ((status === TASK_STATUS.DONE || status === TASK_STATUS.VERIFIED) && task.taskData.percentCompleted !== 100) {
         if (req.body.percentCompleted !== 100) {
           return res.boom.badRequest("Status cannot be updated. Task is not done yet");
         }
       }
     }
 
     if (task.taskData.status === TASK_STATUS.COMPLETED && req.body.percentCompleted < 100) {
-      if (req.body.status === TASK_STATUS.COMPLETED || !req.body.status) {
+      if (status === TASK_STATUS.COMPLETED || !status) {
         return res.boom.badRequest("Task percentCompleted can't updated as status is COMPLETED");
       }
     }
     if (
-      (req.body.status === TASK_STATUS.COMPLETED || req.body.status === TASK_STATUS.VERIFIED) &&
+      (status === TASK_STATUS.COMPLETED || status === TASK_STATUS.VERIFIED) &&
       task.taskData.percentCompleted !== 100
     ) {
       if (req.body.percentCompleted !== 100) {
@@ -386,16 +376,16 @@ const updateTaskStatus = async (req, res, next) => {
       },
     };
 
-    if (req.body.status && !req.body.percentCompleted) {
-      taskLog.body.new.status = req.body.status;
+    if (status && !req.body.percentCompleted) {
+      taskLog.body.new.status = status;
     }
-    if (req.body.percentCompleted && !req.body.status) {
+    if (req.body.percentCompleted && !status) {
       taskLog.body.new.percentCompleted = req.body.percentCompleted;
     }
 
-    if (req.body.percentCompleted && req.body.status) {
+    if (req.body.percentCompleted && status) {
       taskLog.body.new.percentCompleted = req.body.percentCompleted;
-      taskLog.body.new.status = req.body.status;
+      taskLog.body.new.status = status;
     }
 
     const [, taskLogResult] = await Promise.all([
@@ -404,7 +394,7 @@ const updateTaskStatus = async (req, res, next) => {
     ]);
     taskLog.id = taskLogResult.id;
 
-    if (req.body.status) {
+    if (status) {
       userStatusUpdate = await updateStatusOnTaskCompletion(userId);
     }
     return res.json({

controllers/users.js

@@ -20,7 +20,7 @@ const { getOverdueTasks } = require("../models/tasks");
 const { getQualifiers } = require("../utils/helper");
 const { parseSearchQuery } = require("../utils/users");
 const { getFilteredPRsOrIssues } = require("../utils/pullRequests");
-
+const { getFilteredPaginationLink } = require("../utils/userStatus");
 const {
   USERS_PATCH_HANDLER_ACTIONS,
   USERS_PATCH_HANDLER_ERROR_MESSAGES,
@@ -732,16 +732,45 @@ const addDefaultArchivedRole = async (req, res) => {
  * @param res {Object} - Express response object
  */
 
+const calculatePagination = (pageNumber, totalPages, reqQuery, limitNumber) => {
+  const nextPage = pageNumber < totalPages - 1 ? pageNumber + 1 : null;
+  const prevPage = pageNumber > 0 ? pageNumber - 1 : null;
+
+  return {
+    next: nextPage ? getFilteredPaginationLink(reqQuery, nextPage, limitNumber) : null,
+    prev: prevPage ? getFilteredPaginationLink(reqQuery, prevPage, limitNumber) : null,
+  };
+};
+
 const filterUsers = async (req, res) => {
   try {
     if (!Object.keys(req.query).length) {
       return res.boom.badRequest("filter for item not provided");
     }
+    const dev = req.query.dev;
+    if (dev !== "true") {
+      const users = await dataAccess.retreiveFilteredUsers(req.query);
+      return res.json({
+        message: users.length ? "Users found successfully!" : "No users found",
+        users: users,
+        count: users.length,
+      });
+    }
+    const { page, size } = req.query;
+    const pageNumber = parseInt(page) || 0;
+    const limitNumber = parseInt(size) || 100;
+    const skip = (pageNumber - 1) * limitNumber;
+
+    const users = await dataAccess.retreiveFilteredUsers(req.query, skip, limitNumber);
+    const totalCount = users.length;
+    const totalPages = Math.ceil(totalCount / limitNumber);
+
+    const paginationLinks = calculatePagination(pageNumber, totalPages, req.query, limitNumber);
 
-    const users = await dataAccess.retreiveFilteredUsers(req.query);
     return res.json({
       message: users.length ? "Users found successfully!" : "No users found",
       users: users,
+      links: paginationLinks,
       count: users.length,
     });
   } catch (error) {

middlewares/validators/oooRequests.ts

@@ -0,0 +1,63 @@
+import joi from "joi";
+import { NextFunction } from "express";
+import { REQUEST_STATE, REQUEST_TYPE } from "../../constants/request";
+import { OooRequestCreateRequest, OooRequestResponse,OooRequestUpdateRequest } from "../../types/oooRequest";
+
+export const createOooStatusRequestValidator = async (
+  req: OooRequestCreateRequest,
+  res: OooRequestResponse,
+  next: NextFunction
+) => {
+  const schema = joi
+    .object()
+    .strict()
+    .keys({
+      from: joi
+        .number()
+        .min(Date.now())
+        .messages({
+          "number.min": "from date must be greater than or equal to Today's date",
+        })
+        .required(),
+      until: joi
+        .number()
+        .min(joi.ref("from"))
+        .messages({
+          "number.min": "until date must be greater than or equal to from date",
+        })
+        .required(),
+      message: joi.string().required().messages({
+        "any.required": "message is required",
+        "string.empty": "message cannot be empty",
+      }),
+      state: joi.string().valid(REQUEST_STATE.PENDING).required().messages({
+        "any.only": "state must be PENDING",
+      }),
+      type: joi.string().valid(REQUEST_TYPE.OOO).required(),
+    });
+
+  await schema.validateAsync(req.body, { abortEarly: false });
+};
+
+
+export const updateOooStatusRequestValidator = async (
+  req: OooRequestUpdateRequest,
+
+) => {
+  const schema = joi
+    .object()
+    .strict()
+    .keys({
+      reason: joi.string().optional(),
+      state: joi
+        .string()
+        .valid(REQUEST_STATE.APPROVED, REQUEST_STATE.REJECTED)
+        .required()
+        .messages({
+          "any.only": "state must be APPROVED or REJECTED",
+        }),
+      type: joi.string().valid(REQUEST_TYPE.OOO).required(),
+    });
+
+  await schema.validateAsync(req.body, { abortEarly: false });
+};