Merge branch 'develop' into iss2223-tests

Author: Achintya-Chatterjee

controllers/extensionRequests.js

@@ -202,12 +202,22 @@ const getSelfExtensionRequests = async (req, res) => {
  * @param res {Object} - Express response object
  */
 const updateExtensionRequest = async (req, res) => {
+  const { dev } = req.query;
+  const isDev = dev === "true";
   try {
     const extensionRequest = await extensionRequestsQuery.fetchExtensionRequest(req.params.id);
     if (!extensionRequest.extensionRequestData) {
       return res.boom.notFound("Extension Request not found");
     }
 
+    if (
+      isDev &&
+      !req.userData?.roles.super_user &&
+      extensionRequest.extensionRequestData.status !== EXTENSION_REQUEST_STATUS.PENDING
+    ) {
+      return res.boom.badRequest("Only pending extension request can be updated");
+    }
+
     if (req.body.assignee) {
       const { taskData: task } = await tasks.fetchTask(extensionRequest.extensionRequestData.taskId);
       if (task.assignee !== (await getUsername(req.body.assignee))) {

controllers/tasks.js

@@ -13,6 +13,7 @@ const { updateUserStatusOnTaskUpdate, updateStatusOnTaskCompletion } = require("
 const dataAccess = require("../services/dataAccessLayer");
 const { parseSearchQuery } = require("../utils/tasks");
 const { addTaskCreatedAtAndUpdatedAtFields } = require("../services/tasks");
+const tasksService = require("../services/tasks");
 const { RQLQueryParser } = require("../utils/RQLParser");
 const { getMissedProgressUpdatesUsers } = require("../models/discordactions");
 const { logType } = require("../constants/logs");
@@ -134,7 +135,19 @@ const fetchPaginatedTasks = async (query) => {
 
 const fetchTasks = async (req, res) => {
   try {
-    const { status, page, size, prev, next, q: queryString, assignee, title, userFeatureFlag } = req.query;
+    const {
+      status,
+      page,
+      size,
+      prev,
+      next,
+      q: queryString,
+      assignee,
+      title,
+      userFeatureFlag,
+      orphaned,
+      dev,
+    } = req.query;
     const transformedQuery = transformQuery(status, size, page, assignee, title);
 
     if (queryString !== undefined) {
@@ -159,6 +172,28 @@ const fetchTasks = async (req, res) => {
       });
     }
 
+    const isOrphaned = orphaned === "true";
+    const isDev = dev === "true";
+    if (isOrphaned) {
+      if (!isDev) {
+        return res.boom.notFound("Route not found");
+      }
+      try {
+        const orphanedTasks = await tasksService.fetchOrphanedTasks();
+        if (!orphanedTasks || orphanedTasks.length === 0) {
+          return res.sendStatus(204);
+        }
+        const tasksWithRdsAssigneeInfo = await fetchTasksWithRdsAssigneeInfo(orphanedTasks);
+        return res.status(200).json({
+          message: "Orphan tasks fetched successfully",
+          data: tasksWithRdsAssigneeInfo,
+        });
+      } catch (error) {
+        logger.error("Error in getting tasks which were orphaned", error);
+        return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+      }
+    }
+
     const paginatedTasks = await fetchPaginatedTasks({ ...transformedQuery, prev, next, userFeatureFlag });
     return res.json({
       message: "Tasks returned successfully!",

controllers/users.js

@@ -30,6 +30,7 @@ const { addLog } = require("../models/logs");
 const { getUserStatus } = require("../models/userStatus");
 const config = require("config");
 const { generateUniqueUsername } = require("../services/users");
+const userService = require("../services/users");
 const discordDeveloperRoleId = config.get("discordDeveloperRoleId");
 
 const verifyUser = async (req, res) => {
@@ -191,6 +192,30 @@ const getUsers = async (req, res) => {
       }
     }
 
+    const isDeparted = req.query.departed === "true";
+
+    if (isDeparted) {
+      if (!dev) {
+        return res.boom.notFound("Route not found");
+      }
+      try {
+        const result = await dataAccess.retrieveUsers({ query: req.query });
+        const departedUsers = await userService.getUsersWithIncompleteTasks(result.users);
+        if (departedUsers.length === 0) return res.status(204).send();
+        return res.json({
+          message: "Users with abandoned tasks fetched successfully",
+          users: departedUsers,
+          links: {
+            next: result.nextId ? getPaginationLink(req.query, "next", result.nextId) : "",
+            prev: result.prevId ? getPaginationLink(req.query, "prev", result.prevId) : "",
+          },
+        });
+      } catch (error) {
+        logger.error("Error when fetching users who abandoned tasks:", error);
+        return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+      }
+    }
+
     if (transformedQuery?.filterBy === OVERDUE_TASKS) {
       try {
         const tasksData = await getOverdueTasks(days);

middlewares/skipAuthorizeRolesWrapper.js

@@ -0,0 +1,13 @@
+const skipAuthorizeRolesUnderFF = (authorizeMiddleware) => {
+  return (req, res, next) => {
+    const { dev } = req.query;
+    const isDev = dev === "true";
+    if (isDev) {
+      next();
+    } else {
+      authorizeMiddleware(req, res, next);
+    }
+  };
+};
+
+module.exports = skipAuthorizeRolesUnderFF;

middlewares/validators/tasks.js

@@ -193,6 +193,7 @@ const getTasksValidator = async (req, res, next) => {
         return value;
       }, "Invalid query format"),
     userFeatureFlag: joi.string().optional(),
+    orphaned: joi.boolean().optional(),
   });
 
   try {

middlewares/validators/user.js

@@ -200,6 +200,7 @@ async function getUsers(req, res, next) {
       filterBy: joi.string().optional(),
       days: joi.string().optional(),
       dev: joi.string().optional(),
+      departed: joi.string().optional(),
       roles: joi.optional().custom((value, helpers) => {
         if (value !== "member") {
           return helpers.message("only member role is supported");

models/tasks.js

@@ -4,7 +4,6 @@ const userModel = firestore.collection("users");
 const ItemModel = firestore.collection("itemTags");
 const dependencyModel = firestore.collection("taskDependencies");
 const userUtils = require("../utils/users");
-const { updateTaskStatusToDone } = require("../services/tasks");
 const { chunks } = require("../utils/array");
 const { DOCUMENT_WRITE_SIZE } = require("../constants/constants");
 const { fromFirestoreData, toFirestoreData, buildTasks } = require("../utils/tasks");
@@ -24,6 +23,42 @@ const {
 const { OLD_ACTIVE, OLD_BLOCKED, OLD_PENDING, OLD_COMPLETED } = TASK_STATUS_OLD;
 const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
 
+/**
+ * Update multiple tasks' status to DONE in one batch operation.
+ * @param {Object[]} tasksData - Tasks data to update, must contain 'id' and 'status' fields.
+ * @returns {Object} - Summary of the batch operation.
+ * @property {number} totalUpdatedStatus - Number of tasks that has their status updated to DONE.
+ * @property {number} totalOperationsFailed - Number of tasks that failed to update.
+ * @property {string[]} updatedTaskDetails - IDs of tasks that has their status updated to DONE.
+ * @property {string[]} failedTaskDetails - IDs of tasks that failed to update.
+ */
+const updateTaskStatusToDone = async (tasksData) => {
+  const batch = firestore.batch();
+  const tasksBatch = [];
+  const summary = {
+    totalUpdatedStatus: 0,
+    totalOperationsFailed: 0,
+    updatedTaskDetails: [],
+    failedTaskDetails: [],
+  };
+  tasksData.forEach((task) => {
+    const updateTaskData = { ...task, status: "DONE" };
+    batch.update(tasksModel.doc(task.id), updateTaskData);
+    tasksBatch.push(task.id);
+  });
+  try {
+    await batch.commit();
+    summary.totalUpdatedStatus += tasksData.length;
+    summary.updatedTaskDetails = [...tasksBatch];
+    return { ...summary };
+  } catch (err) {
+    logger.error("Firebase batch Operation Failed!");
+    summary.totalOperationsFailed += tasksData.length;
+    summary.failedTaskDetails = [...tasksBatch];
+    return { ...summary };
+  }
+};
+
 /**
  * Adds and Updates tasks
  *
@@ -701,6 +736,33 @@ const markUnDoneTasksOfArchivedUsersBacklog = async (users) => {
   }
 };
 
+/**
+ * Fetches all incomplete tasks for given user IDs.
+ *
+ * @param {string[]} userIds - The IDs of the users to fetch incomplete tasks for.
+ * @returns {Promise<firebase.firestore.QuerySnapshot>} - The query snapshot object.
+ * @throws {Error} - Throws an error if the database query fails.
+ */
+const fetchIncompleteTasksByUserIds = async (userIds) => {
+  const COMPLETED_STATUSES = [DONE, COMPLETED];
+
+  if (!userIds || userIds.length === 0) {
+    return [];
+  }
+  try {
+    const incompleteTasksQuery = await tasksModel.where("assigneeId", "in", userIds).get();
+
+    const incompleteTaskForUsers = incompleteTasksQuery.docs.filter(
+      (task) => !COMPLETED_STATUSES.includes(task.data().status)
+    );
+
+    return incompleteTaskForUsers;
+  } catch (error) {
+    logger.error("Error when fetching incomplete tasks for users:", error);
+    throw error;
+  }
+};
+
 module.exports = {
   updateTask,
   fetchTasks,
@@ -720,4 +782,6 @@ module.exports = {
   updateTaskStatus,
   updateOrphanTasksStatus,
   markUnDoneTasksOfArchivedUsersBacklog,
+  updateTaskStatusToDone,
+  fetchIncompleteTasksByUserIds,
 };

models/users.js

@@ -8,8 +8,12 @@ const firestore = require("../utils/firestore");
 const { fetchWallet, createWallet } = require("../models/wallets");
 const { updateUserStatus } = require("../models/userStatus");
 const { arraysHaveCommonItem, chunks } = require("../utils/array");
-const { archiveUsers } = require("../services/users");
-const { ALLOWED_FILTER_PARAMS, FIRESTORE_IN_CLAUSE_SIZE } = require("../constants/users");
+const {
+  ALLOWED_FILTER_PARAMS,
+  FIRESTORE_IN_CLAUSE_SIZE,
+  USERS_PATCH_HANDLER_SUCCESS_MESSAGES,
+  USERS_PATCH_HANDLER_ERROR_MESSAGES,
+} = require("../constants/users");
 const { DOCUMENT_WRITE_SIZE } = require("../constants/constants");
 const { userState } = require("../constants/userStatus");
 const { BATCH_SIZE_IN_CLAUSE } = require("../constants/firebase");
@@ -27,6 +31,52 @@ const { formatUsername } = require("../utils/username");
 const { logType } = require("../constants/logs");
 const { addLog } = require("../services/logService");
 
+/**
+ * Archive users by setting the roles.archived field to true.
+ * This function commits the write in batches to avoid reaching the maximum number of writes per batch.
+ * @param {Array} usersData - An array of user objects with the following properties: id, first_name, last_name
+ * @returns {Promise} - A promise that resolves with a summary object containing the number of users updated and failed, and an array of updated and failed user details.
+ */
+const archiveUsers = async (usersData) => {
+  const batch = firestore.batch();
+  const usersBatch = [];
+  const summary = {
+    totalUsersArchived: 0,
+    totalOperationsFailed: 0,
+    updatedUserDetails: [],
+    failedUserDetails: [],
+  };
+
+  usersData.forEach((user) => {
+    const { id, first_name: firstName, last_name: lastName } = user;
+    const updatedUserData = {
+      ...user,
+      roles: {
+        ...user.roles,
+        archived: true,
+      },
+      updated_at: Date.now(),
+    };
+    batch.update(userModel.doc(id), updatedUserData);
+    usersBatch.push({ id, firstName, lastName });
+  });
+
+  try {
+    await batch.commit();
+    summary.totalUsersArchived += usersData.length;
+    summary.updatedUserDetails = [...usersBatch];
+    return {
+      message: USERS_PATCH_HANDLER_SUCCESS_MESSAGES.ARCHIVE_USERS.SUCCESSFULLY_COMPLETED_BATCH_UPDATES,
+      ...summary,
+    };
+  } catch (err) {
+    logger.error("Firebase batch Operation Failed!");
+    summary.totalOperationsFailed += usersData.length;
+    summary.failedUserDetails = [...usersBatch];
+    return { message: USERS_PATCH_HANDLER_ERROR_MESSAGES.ARCHIVE_USERS.BATCH_DATA_UPDATED_FAILED, ...summary };
+  }
+};
+
 /**
  * Adds or updates the user data
  *
@@ -190,11 +240,11 @@ const getSuggestedUsers = async (skill) => {
  */
 const fetchPaginatedUsers = async (query) => {
   const isDevMode = query.dev === "true";
-
   try {
     const size = parseInt(query.size) || 100;
     const doc = (query.next || query.prev) && (await userModel.doc(query.next || query.prev).get());
 
+    const isArchived = query.departed === "true";
     let dbQuery;
     /**
      * !!NOTE : At the time of writing we only support member in the role query
@@ -203,9 +253,9 @@ const fetchPaginatedUsers = async (query) => {
      * if you're making changes to this code remove the archived check in the role query, example: role=archived,member
      */
     if (query.roles === "member") {
-      dbQuery = userModel.where("roles.archived", "==", false).where("roles.member", "==", true);
+      dbQuery = userModel.where("roles.archived", "==", isArchived).where("roles.member", "==", true);
     } else {
-      dbQuery = userModel.where("roles.archived", "==", false).orderBy("username");
+      dbQuery = userModel.where("roles.archived", "==", isArchived).orderBy("username");
     }
 
     let compositeQuery = [dbQuery];
@@ -225,6 +275,10 @@ const fetchPaginatedUsers = async (query) => {
     }
 
     if (Object.keys(query).length) {
+      if (query.departed) {
+        compositeQuery = compositeQuery.map((query) => query.where("roles.in_discord", "==", false));
+        dbQuery = dbQuery.where("roles.in_discord", "==", false);
+      }
       if (query.search) {
         const searchValue = query.search.toLowerCase().trim();
         dbQuery = dbQuery.startAt(searchValue).endAt(searchValue + "\uf8ff");
@@ -1038,7 +1092,26 @@ const updateUsersWithNewUsernames = async () => {
   }
 };
 
+/**
+ * Fetches users who are not in the Discord server.
+ * @returns {Promise<FirebaseFirestore.QuerySnapshot>} - A promise that resolves to a Firestore QuerySnapshot containing the users matching the criteria.
+ * @throws {Error} - Throws an error if the database query fails.
+ */
+const fetchUsersNotInDiscordServer = async () => {
+  try {
+    const usersNotInDiscordServer = await userModel
+      .where("roles.archived", "==", true)
+      .where("roles.in_discord", "==", false)
+      .get();
+    return usersNotInDiscordServer;
+  } catch (error) {
+    logger.error(`Error in getting users who are not in discord server:  ${error}`);
+    throw error;
+  }
+};
+
 module.exports = {
+  archiveUsers,
   addOrUpdate,
   fetchPaginatedUsers,
   fetchUser,
@@ -1067,4 +1140,5 @@ module.exports = {
   fetchUserForKeyValue,
   getNonNickNameSyncedUsers,
   updateUsersWithNewUsernames,
+  fetchUsersNotInDiscordServer,
 };

routes/extensionRequests.js

@@ -10,15 +10,17 @@ const {
   updateExtensionRequestStatus,
   getExtensionRequestsValidator,
 } = require("../middlewares/validators/extensionRequests");
+const skipAuthorizeRolesUnderFF = require("../middlewares/skipAuthorizeRolesWrapper");
 
 router.post("/", authenticate, createExtensionRequest, extensionRequests.createTaskExtensionRequest);
 router.get("/", authenticate, getExtensionRequestsValidator, extensionRequests.fetchExtensionRequests);
 router.get("/self", authenticate, extensionRequests.getSelfExtensionRequests);
 router.get("/:id", authenticate, authorizeRoles([SUPERUSER, APPOWNER]), extensionRequests.getExtensionRequest);
+//  remove the skipAuthorizeRolesUnderFF & authorizeRoles middleware when removing the feature flag
 router.patch(
   "/:id",
   authenticate,
-  authorizeRoles([SUPERUSER, APPOWNER]),
+  skipAuthorizeRolesUnderFF(authorizeRoles([SUPERUSER, APPOWNER])),
   updateExtensionRequest,
   extensionRequests.updateExtensionRequest
 );