Works for batch status updates

Harsh Patel · Harsh Patel · commit 1bee227db087 · 2019-10-26T16:15:22.000-04:00
diff --git a/constants/general.constant.js b/constants/general.constant.js
@@ -23,6 +23,16 @@ const HACKER_STATUSES = [
     HACKER_STATUS_CANCELLED,
     HACKER_STATUS_CHECKED_IN
 ];
+const VALID_SEARCH_ACTIONS = [
+    "change_status",
+    "email",
+    "change_status_and_email"
+];
+
+const CORRESPONDING_STATUSES = {
+    "change_status": HACKER_STATUSES,
+    "email": ["Acceptance", "Waitlist", "Reminder"]
+}
 
 const SAMPLE_DIET_RESTRICTIONS = [
     "None",
@@ -151,4 +161,6 @@ module.exports = {
     MAX_TEAM_SIZE: MAX_TEAM_SIZE,
     WEEK_OF: WEEK_OF,
     SAMPLE_DIET_RESTRICTIONS: SAMPLE_DIET_RESTRICTIONS,
+    VALID_SEARCH_ACTIONS: VALID_SEARCH_ACTIONS,
+    CORRESPONDING_STATUSES: CORRESPONDING_STATUSES
 };
diff --git a/constants/routes.constant.js b/constants/routes.constant.js
@@ -214,7 +214,11 @@ const searchRoutes = {
     "get": {
         requestType: Constants.REQUEST_TYPES.GET,
         uri: "/api/search/"
-    }
+    },
+    "bactchAction": {
+        requestType: Constants.REQUEST_TYPES.GET,
+        uri: "/api/search/action",
+    },
 };
 
 const staffRoutes = {
diff --git a/middlewares/search.middleware.js b/middlewares/search.middleware.js
@@ -15,7 +15,6 @@ const Middleware = {
  */
 function parseQuery(req, res, next) {
     let query = req.body.q;
-
     req.body.q = JSON.parse(query);
 
     //Default page
@@ -62,6 +61,29 @@ async function executeQuery(req, res, next) {
     return next();
 }
 
+/**
+ * 
+ * @param {} req 
+ * @param {*} res 
+ * @param {*} next
+ * 
+ * @returns 
+ */
+async function executeStatusAction(req, res, next) {
+    // NOW HAVE req.body.results as an array of "hackers potentially"
+    console.log("GETS IN EXECUTE STATUS ACTION BRO!")
+    req.body.results = await Services.Search.executeAction(req.body.model,
+        req.body.q,
+        req.body.page,
+        req.body.limit,
+        req.body.sort,
+        req.body.sort_by,
+        req.body.expand,
+        req.body.status
+    );
+    return next();
+}
+
 function setExpandTrue(req, res, next) {
     req.body.expand = true;
     next();
@@ -71,5 +93,6 @@ function setExpandTrue(req, res, next) {
 module.exports = {
     parseQuery: parseQuery,
     executeQuery: Middleware.Util.asyncMiddleware(executeQuery),
+    executeStatusAction: Middleware.Util.asyncMiddleware(executeStatusAction),
     setExpandTrue: setExpandTrue,
 };
diff --git a/middlewares/validators/search.validator.js b/middlewares/validators/search.validator.js
@@ -11,4 +11,16 @@ module.exports = {
         VALIDATOR.booleanValidator("query", "expand", true),
         VALIDATOR.searchValidator("query", "q")
     ],
+    searchActionValidator: [
+        VALIDATOR.searchModelValidator("query", "model", false),
+        VALIDATOR.alphaValidator("query", "sort", true),
+        VALIDATOR.integerValidator("query", "page", true, 0),
+        VALIDATOR.integerValidator("query", "limit", true, 0, 1000),
+        VALIDATOR.searchSortValidator("query", "sort_by"),
+        VALIDATOR.booleanValidator("query", "expand", true),
+        VALIDATOR.searchValidator("query", "q"),
+        /* ACTION VALIDATOR NEED TO MAKE WORK! */
+        VALIDATOR.actionValidator("query", "action"),
+        VALIDATOR.statusValidator("query", "status")
+    ],
 };
diff --git a/middlewares/validators/validator.helper.js b/middlewares/validators/validator.helper.js
@@ -27,8 +27,8 @@ function integerValidator(fieldLocation, fieldname, optional = true, lowerBound
 
     if (optional) {
         return value.optional({
-                checkFalsy: true
-            })
+            checkFalsy: true
+        })
             .isInt().withMessage(`${fieldname} must be an integer.`)
             .custom((value) => {
                 return value >= lowerBound && value <= upperBound;
@@ -71,8 +71,8 @@ function mongoIdArrayValidator(fieldLocation, fieldname, optional = true) {
 
     if (optional) {
         return arr.optional({
-                checkFalsy: true
-            })
+            checkFalsy: true
+        })
             .custom(isMongoIdArray).withMessage("Value must be an array of mongoIDs");
     } else {
         return arr.exists()
@@ -137,8 +137,8 @@ function regexValidator(fieldLocation, fieldname, optional = true, desire = Cons
 
     if (optional) {
         return match.optional({
-                checkFalsy: true
-            })
+            checkFalsy: true
+        })
             .matches(desire)
             .withMessage("must be valid url");
     } else {
@@ -315,8 +315,8 @@ function jwtValidator(fieldLocation, fieldname, jwtSecret, optional = true) {
     const jwtValidationChain = setProperValidationChainBuilder(fieldLocation, fieldname, "Must be vali jwt");
     if (optional) {
         return jwtValidationChain.optional({
-                checkFalsy: true
-            })
+            checkFalsy: true
+        })
             .custom(value => {
                 const token = jwt.verify(value, jwtSecret);
                 if (typeof token !== "undefined") {
@@ -406,8 +406,8 @@ function searchValidator(fieldLocation, fieldname) {
 function searchSortValidator(fieldLocation, fieldName) {
     const searchSort = setProperValidationChainBuilder(fieldLocation, fieldName, "Invalid sort criteria")
     return searchSort.optional({
-            checkFalsy: true
-        })
+        checkFalsy: true
+    })
         .custom((value, {
             req
         }) => {
@@ -551,6 +551,38 @@ function enumValidator(fieldLocation, fieldname, enums, optional = true) {
     }
 }
 
+/**
+ * Validates that action field is a valid action from constants passed, and checks if corresponding new status is valid.
+ * @param {"query" | "body" | "header" | "param"} fieldLocation The location where the field should be found.
+ * @param {string} actionFieldName The name of the action that needs to be performed.
+ * @param {string} statusFieldName The name of the action that needs to be performed.
+ */
+function actionValidator(fieldLocation, actionFieldName) {
+    const actionValue = setProperValidationChainBuilder(fieldLocation, actionFieldName, "Invalid action.");
+
+    return actionValue.exists()
+        .withMessage("The action must exist.")
+        .custom(actionValidatorHelper).withMessage("The value must be a valid action.");
+}
+
+
+function statusValidator(fieldLocation, statusFieldName) {
+    const statusValue = setProperValidationChainBuilder(fieldLocation, statusFieldName, "Invalid status.");
+    return statusValue.exists().withMessage("The status must exist!").custom((val, {
+        req
+    }) => {
+        return Constants.CORRESPONDING_STATUSES[req.query.action].includes(val);
+    }).withMessage("The value must be a proper status.")
+}
+
+function actionValidatorHelper(action) {
+    if (Constants.VALID_SEARCH_ACTIONS.includes(action)) {
+        return true;
+    }
+    return false;
+}
+
+
 /**
  * Checks that 'value' is part of 'enums'. 'enums' should be an enum dict.
  * @param {*} value Should be of the same type as the values of the enum
@@ -614,4 +646,6 @@ module.exports = {
     dateValidator: dateValidator,
     enumValidator: enumValidator,
     routesValidator: routesValidator,
+    actionValidator: actionValidator,
+    statusValidator: statusValidator
 };
diff --git a/routes/api/search.js b/routes/api/search.js
@@ -67,6 +67,56 @@ module.exports = {
             Controllers.Search.searchResults
         );
 
+        /**
+         * @api {get} /search/action execute an action on a specific query for any defined model
+         * @apiName search
+         * @apiGroup Search
+         * @apiVersion 0.0.8
+         *
+         * @apiParam (query) {String} model the model to be searched
+         * @apiParam (query) {Array} q the query to be executed. For more information on how to format this, please see https://docs.mchacks.ca/architecture/
+         * @apiParam (query) {String} model the model to be searched
+         * @apiParam (query) {String} sort either "asc" or "desc"
+         * @apiParam (query) {number} page the page number that you would like
+         * @apiParam (query) {number} limit the maximum number of results that you would like returned
+         * @apiParam (query) {any} sort_by any parameter you want to sort the results by
+         * @apiParam (query) {boolean} expand whether you want to expand sub documents within the results
+         * @apiParam (query) {String} action type of action either Status or Email
+         * @apiParam (query) {String} status new status or type of email
+         * 
+         * @apiSuccess {String} message Success message
+         * @apiSuccess {Object} data Results
+         * @apiSuccessExample {object} Success-Response:
+         *      {
+                    "message": "Successfully executed query, returning all results",
+                    "data": [
+                        {...}
+                    ]
+                }
+         *
+         * @apiSuccess {String} message Success message
+         * @apiSuccess {Object} data Empty object
+         * @apiSuccessExample {object} Success-Response:
+         *      {
+                    "message": "No results found.",
+                    "data": {}
+                }
+         *
+         * @apiError {String} message Error message
+         * @apiError {Object} data empty
+         * @apiErrorExample {object} Error-Response:
+         *      {"message": "Validation failed", "data": {}}
+         */
+        searchRouter.route("/action").get(
+            Middleware.Auth.ensureAuthenticated(),
+            Middleware.Auth.ensureAuthorized(),
+            Middleware.Validator.Search.searchActionValidator,
+            Middleware.parseBody.middleware,
+            Middleware.Search.parseQuery,
+            Middleware.Search.executeStatusAction,
+            Controllers.Search.searchResults
+        );
+
         apiRouter.use("/search", searchRouter);
     }
 };
diff --git a/services/search.service.js b/services/search.service.js
@@ -72,6 +72,80 @@ function executeQuery(model, queryArray, page, limit, sort, sort_by, shouldExpan
         .exec();
 }
 
+
+/**
+ * @function executeAction
+ * @param {string} model the model which is being searched
+ * @param {Array} queryArray array of clauses for the query
+ * @param {number} page the page number you want
+ * @param {number} limit the limit to the number of responses you want
+ * @param {"asc"|"desc"} sort which direction you want to sort by
+ * @param {string} sort_by the attribute you want to sort by
+ * @param {string} new_status the status you want to set of the queried model
+ * @returns {Promise<[Array]>}
+ * @description Builds and executes a search query based on a subset of mongodb
+ */
+function executeAction(model, queryArray, page, limit, sort, sort_by, shouldExpand = false, new_status) {
+    var query;
+    console.log("GETS IN EXECUTE ACTION BRO!")
+    switch (model.toLowerCase()) {
+        case "hacker":
+            query = (shouldExpand) ? Hacker.find().populate([{
+                path: "accountId",
+                select: " -password"
+            }, {
+                path: "teamId"
+            }]) : Hacker.find();
+            break;
+        default:
+            return [];
+    }
+    for (var i in queryArray) {
+        var clause = queryArray[i];
+        var param = clause.param;
+        var val = clause.value;
+        switch (clause.operation) {
+            case "equals":
+                query.where(param).equals(val);
+                break;
+            case "ne":
+                query.where(param).ne(val);
+                break;
+            case "lt":
+                query.where(param).lt(val);
+                break;
+            case "gt":
+                query.where(param).gt(val);
+                break;
+            case "lte":
+                query.where(param).lte(val);
+                break;
+            case "gte":
+                query.where(param).gte(val);
+                break;
+            case "in":
+                query.where(param).in(val);
+                break;
+            case "regex":
+                query.where(param).regex(val);
+                break;
+            case "elemMatch":
+                query.where(param).elemMatch(val);
+                break;
+        }
+    }
+
+    if (sort == "desc") {
+        query.sort("-" + sort_by);
+    } else if (sort == "asc") {
+        query.sort(sort_by);
+    }
+    return query.limit(limit)
+        .skip(limit * page).updateMany({ $set: { "status": new_status } })
+        .exec();
+}
+
 module.exports = {
-    executeQuery: executeQuery
+    executeQuery: executeQuery,
+    executeAction: executeAction
 };
