added 2 APIs

controllers/extensionRequests.js

@@ -40,7 +40,7 @@ const createTaskExtensionRequest = async (req, res) => {
  return res.boom.forbidden("An extension request for this task already exists.");
  }
 
- const extensionRequest = await extensionRequestsQuery.createETAExtension(extensionBody);
+ const extensionRequest = await extensionRequestsQuery.createExtensionRequest(extensionBody);
 
  const extensionLog = {
  type: "extensionRequest",
@@ -104,8 +104,53 @@ const getExtensionRequest = async (req, res) => {
  }
 };
 
+/**
+ * Fetches all the extension requests of the logged in user
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+const getSelfExtensionRequests = async (req, res) => {
+ try {
+ const { id: userId } = req.userData;
+ const { taskId, status } = req.query;
+
+ if (userId) {
+ const allExtensionRequests = await extensionRequestsQuery.fetchUserExtensionRequests(userId, status, taskId);
+ return res.json({ message: "Extension Requests returned successfully!", allExtensionRequests });
+ }
+ return res.boom.notFound("User doesn't exist");
+ } catch (error) {
+ logger.error(`Error while fetching extension requests: ${error}`);
+ return res.boom.badImplementation("An internal server error occured");
+ }
+};
+
+/**
+ * Updates the Extension Request
+ *
+ * @param req {Object} - Express request object
+ * @param res {Object} - Express response object
+ */
+const updateExtensionRequest = async (req, res) => {
+ try {
+ const extensionRequest = await extensionRequestsQuery.fetchExtensionRequest(req.params.id);
+ if (!extensionRequest.extensionRequestData) {
+ return res.boom.notFound("Extension Request not found");
+ }
+
+ await extensionRequestsQuery.updateExtensionRequest(req.body, req.params.id);
+ return res.status(204).send();
+ } catch (err) {
+ logger.error(`Error while updating extension request: ${err}`);
+ return res.boom.badImplementation("An internal server error occurred");
+ }
+};
+
 module.exports = {
  createTaskExtensionRequest,
  fetchExtensionRequests,
  getExtensionRequest,
+ getSelfExtensionRequests,
+ updateExtensionRequest,
 };

middlewares/validators/extensionRequests.js

@@ -24,6 +24,33 @@ const createExtensionRequest = async (req, res, next) => {
  }
 };
 
+const updateExtensionRequest = async (req, res, next) => {
+ const schema = joi
+ .object()
+ .strict()
+ .keys({
+ taskId: joi.string().optional(),
+ title: joi.string().optional(),
+ assignee: joi.string().optional(),
+ oldEndsOn: joi.number().optional(),
+ newEndsOn: joi.number().optional(),
+ reason: joi.string().optional(),
+ status: joi
+ .string()
+ .valid(...Object.values(ETA_EXTENSION_REQUEST_STATUS))
+ .optional(),
+ });
+
+ try {
+ await schema.validateAsync(req.body);
+ next();
+ } catch (error) {
+ logger.error(`Error validating updateExtensionRequest payload : ${error}`);
+ res.boom.badRequest(error.details[0].message);
+ }
+};
+
 module.exports = {
  createExtensionRequest,
+ updateExtensionRequest,
 };

models/extensionRequests.js

@@ -4,13 +4,13 @@ const { buildExtensionRequests, formatExtensionRequest } = require("../utils/ext
 
 /**
  * Create Extension Request
- * @param body { Object }: Body of the extension request
+ * @param extensionRequestData { Object }: Body of the extension request
  */
-const createETAExtension = async (body) => {
+const createExtensionRequest = async (extensionRequestData) => {
  try {
  const request = {
  timestamp: (new Date().getTime() / 1000).toFixed(0),
- ...body,
+ ...extensionRequestData,
  };
  return await extensionRequestsModel.add(request);
  } catch (err) {
@@ -19,6 +19,27 @@ const createETAExtension = async (body) => {
  }
 };
 
+/**
+ * Updates Extension Request
+ *
+ * @param extensionRequestData { Object }: extension request data object to be stored in DB
+ * @param extensionRequestId { string }: extensionRequestId which will be used to update the task in DB
+ * @return {extensionRequestResult : Object}
+ */
+const updateExtensionRequest = async (extensionRequestData, extensionRequestId) => {
+ try {
+ const extensionRequest = await extensionRequestsModel.doc(extensionRequestId).get();
+ await extensionRequestsModel.doc(extensionRequestId).set({
+ ...extensionRequest.data(),
+ ...extensionRequestData,
+ });
+ return extensionRequestId;
+ } catch (err) {
+ logger.error("Error in updating task", err);
+ throw err;
+ }
+};
+
 /**
  * Fetch all Extension Requests
  * @param extensionRequestquery { Object }: Body of the extension request
@@ -56,8 +77,48 @@ const fetchExtensionRequest = async (extensionRequestId) => {
  }
 };
 
+/**
+ * Fetch all Extension Requests of a user
+ *
+ * @return {Array<extensionRequests>}
+ */
+
+const fetchUserExtensionRequests = async (userId, status, taskId) => {
+ try {
+ if (!userId) {
+ return { userNotFound: true };
+ }
+
+ let extensionRequestsSnapshot = [];
+
+ let extensionRequestQuery = extensionRequestsModel.where("assignee", "==", userId);
+
+ if (taskId) {
+ extensionRequestQuery = extensionRequestQuery.where("taskId", "==", taskId);
+ }
+
+ if (status) {
+ extensionRequestQuery = extensionRequestQuery.where("status", "==", status);
+ }
+
+ extensionRequestsSnapshot = await extensionRequestQuery.get();
+
+ const extensionRequests = buildExtensionRequests(extensionRequestsSnapshot);
+
+ const promises = extensionRequests.map(async (extensionRequest) => formatExtensionRequest(extensionRequest));
+ const extensionRequestList = await Promise.all(promises);
+
+ return extensionRequestList;
+ } catch (error) {
+ logger.error("error getting extension requests", error);
+ throw error;
+ }
+};
+
 module.exports = {
- createETAExtension,
+ createExtensionRequest,
  fetchExtensionRequests,
  fetchExtensionRequest,
+ fetchUserExtensionRequests,
+ updateExtensionRequest,
 };

routes/extensionRequests.js

@@ -4,10 +4,24 @@ const extensionRequests = require("../controllers/extensionRequests");
 const authenticate = require("../middlewares/authenticate");
 const authorizeRoles = require("../middlewares/authorizeRoles");
 const { SUPERUSER, APPOWNER } = require("../constants/roles");
-const { createExtensionRequest } = require("../middlewares/validators/extensionRequests");
+const { createExtensionRequest, updateExtensionRequest } = require("../middlewares/validators/extensionRequests");
 
-router.post("/", authenticate, createExtensionRequest, extensionRequests.createTaskExtensionRequest);
+router.post(
+ "/",
+ authenticate,
+ authorizeRoles([SUPERUSER, APPOWNER]),
+ createExtensionRequest,
+ extensionRequests.createTaskExtensionRequest
+);
 router.get("/", authenticate, authorizeRoles([SUPERUSER, APPOWNER]), extensionRequests.fetchExtensionRequests);
+router.get("/self", authenticate, extensionRequests.getSelfExtensionRequests);
 router.get("/:id", authenticate, authorizeRoles([SUPERUSER, APPOWNER]), extensionRequests.getExtensionRequest);
+router.patch(
+ "/:id",
+ authenticate,
+ authorizeRoles([SUPERUSER, APPOWNER]),
+ updateExtensionRequest,
+ extensionRequests.updateExtensionRequest
+);
 
 module.exports = router;

test/integration/extensionRequests.test.js

@@ -102,7 +102,7 @@ describe("Extension Requests", function () {
  reason: "family event",
  status: "PENDING",
  };
- extensionRequestId = (await extensionRequests.createETAExtension(extensionRequest)).id;
+ extensionRequestId = (await extensionRequests.createExtensionRequest(extensionRequest)).id;
  });
 
  after(async function () {

utils/extensionRequests.js

@@ -13,10 +13,10 @@ const buildExtensionRequests = (extensionRequests, initialArray = []) => {
  return initialArray;
 };
 
-const formatExtensionRequest = async (request) => {
- if (!request) return request;
+const formatExtensionRequest = async (extensionRequest) => {
+ if (!extensionRequest) return extensionRequest;
 
- let { timestamp, id, assignee, ...body } = request;
+ let { timestamp, id, assignee, ...body } = extensionRequest;
 
  if (assignee) {
  assignee = await getUsername(assignee);