adds the route to get a specific document

Author: heyrandhir

constants/progresses.js

@@ -11,4 +11,9 @@ const RESPONSE_MESSAGES = {
   PROGRESS_ALREADY_CREATED,
 };
 
-module.exports = { RESPONSE_MESSAGES, MILLISECONDS_IN_DAY };
+const TYPE_MAP = {
+  user: "userId",
+  task: "taskId",
+};
+
+module.exports = { RESPONSE_MESSAGES, MILLISECONDS_IN_DAY, TYPE_MAP };

controllers/progresses.js

@@ -1,5 +1,10 @@
 const { Conflict, NotFound } = require("http-errors");
-const { createProgressDocument, getProgressDocument, getRangeProgressData } = require("../models/progresses");
+const {
+  createProgressDocument,
+  getProgressDocument,
+  getRangeProgressData,
+  getProgressByDate,
+} = require("../models/progresses");
 const { RESPONSE_MESSAGES } = require("../constants/progresses");
 const { PROGRESS_DOCUMENT_RETRIEVAL_SUCCEEDED, PROGRESS_DOCUMENT_CREATED_SUCCEEDED } = RESPONSE_MESSAGES;
 
@@ -171,4 +176,57 @@ const getProgressRangeData = async (req, res) => {
   }
 };
 
-module.exports = { createProgress, getProgress, getProgressRangeData };
+/**
+ * @typedef {Object} progressPathParams
+ * @property {string} type - The type of progress document user or task.
+ * @property {string} typeId - The ID of the type.
+ * @property {string} date - The iso format date of the query.
+ */
+
+/**
+ * @typedef {Object} ProgressDocument
+ * @property {string} id - The id of the progress document.
+ * @property {string} type - The type of progress document.
+ * @property {string} completed - The completed progress.
+ * @property {string} planned - The planned progress.
+ * @property {string} blockers - The blockers.
+ * @property {string} userId - The User ID
+ * @property {string} [taskId] - The task ID (optional).
+ * @property {number} createdAt - The timestamp when the progress document was created.
+ * @property {number} date - The timestamp for the day the progress document was created.
+ */
+
+/**
+ * @typedef {Object} GetProgressByDateResponse
+ * @property {string} message - The success message.
+ * @property {ProgressDocument} data - An array of progress documents
+ */
+
+/**
+ * Retrieves the progress documents based on provided query parameters.
+ * @param {Object} req - The HTTP request object.
+ * @param {progressPathParams} req.params - The query parameters
+ * @param {Object} res - The HTTP response object.
+ * @returns {Promise<void>} A Promise that resolves when the response is sent.
+ */
+
+const getProgressBydDateController = async (req, res) => {
+  try {
+    const data = await getProgressByDate(req.params);
+    return res.json({
+      message: PROGRESS_DOCUMENT_RETRIEVAL_SUCCEEDED,
+      data,
+    });
+  } catch (error) {
+    if (error instanceof NotFound) {
+      return res.status(404).json({
+        message: error.message,
+      });
+    }
+    return res.status(400).json({
+      message: error.message,
+    });
+  }
+};
+
+module.exports = { createProgress, getProgress, getProgressRangeData, getProgressBydDateController };

middlewares/validators/progresses.js

@@ -92,8 +92,26 @@ const validateGetRangeProgressRecordsParams = async (req, res, next) => {
     res.boom.badRequest(error.details[0].message);
   }
 };
+
+const validateGetDayProgressParams = async (req, res, next) => {
+  const schema = joi.object({
+    type: joi.string().valid("user", "task").required().messages({
+      "any.only": "Type field is restricted to either 'user' or 'task'.",
+    }),
+    typeId: joi.string().required(),
+    date: joi.date().iso().required(),
+  });
+  try {
+    await schema.validateAsync(req.params, { abortEarly: false });
+    next();
+  } catch (error) {
+    logger.error(`Error validating payload: ${error}`);
+    res.boom.badRequest(error.details[0].message);
+  }
+};
 module.exports = {
   validateCreateProgressRecords,
   validateGetProgressRecordsQuery,
   validateGetRangeProgressRecordsParams,
+  validateGetDayProgressParams,
 };

models/progresses.js

@@ -1,7 +1,7 @@
-const { Conflict } = require("http-errors");
+const { Conflict, NotFound } = require("http-errors");
 const fireStore = require("../utils/firestore");
 const progressesCollection = fireStore.collection("progresses");
-const { RESPONSE_MESSAGES } = require("../constants/progresses");
+const { RESPONSE_MESSAGES, TYPE_MAP } = require("../constants/progresses");
 const {
   buildQueryToFetchDocs,
   getProgressDocs,
@@ -11,8 +11,9 @@ const {
   buildQueryForPostingProgress,
   assertTaskExists,
   getProgressDateTimestamp,
+  buildQueryToSearchProgressByDay,
 } = require("../utils/progresses");
-const { PROGRESS_ALREADY_CREATED } = RESPONSE_MESSAGES;
+const { PROGRESS_ALREADY_CREATED, PROGRESS_DOCUMENT_NOT_FOUND } = RESPONSE_MESSAGES;
 
 /**
  * Adds a new progress document for the given user or task, with a limit of one progress document per day.
@@ -68,4 +69,22 @@ const getRangeProgressData = async (queryParams) => {
   };
 };
 
-module.exports = { createProgressDocument, getProgressDocument, getRangeProgressData };
+/**
+ * This function fetches the progress records for a particular user or task on the specified date.
+ * @param pathParams {object} This is the data that will be used for querying the db. It should contain type, typeId and date
+ * @returns {Promise<object>} A Promise that resolves with the progress records of the queried user or task.
+ * @throws {Error} If the userId or taskId is invalid or does not exist.
+ **/
+async function getProgressByDate(pathParams) {
+  const { type, typeId, date } = pathParams;
+  await assertUserOrTaskExists({ [TYPE_MAP[type]]: typeId });
+  const query = buildQueryToSearchProgressByDay({ [TYPE_MAP[type]]: typeId, date });
+  const result = await query.get();
+  if (!result.size) {
+    throw new NotFound(PROGRESS_DOCUMENT_NOT_FOUND);
+  }
+  const doc = result.docs[0];
+  return { id: doc.id, ...doc.data() };
+}
+
+module.exports = { createProgressDocument, getProgressDocument, getRangeProgressData, getProgressByDate };

routes/progresses.js

@@ -5,11 +5,18 @@ const {
   validateCreateProgressRecords,
   validateGetProgressRecordsQuery,
   validateGetRangeProgressRecordsParams,
+  validateGetDayProgressParams,
 } = require("../middlewares/validators/progresses");
-const { createProgress, getProgress, getProgressRangeData } = require("../controllers/progresses");
+const {
+  createProgress,
+  getProgress,
+  getProgressRangeData,
+  getProgressBydDateController,
+} = require("../controllers/progresses");
 
 router.post("/", authenticate, validateCreateProgressRecords, createProgress);
 router.get("/", validateGetProgressRecordsQuery, getProgress);
+router.get("/:type/:typeId/date/:date", validateGetDayProgressParams, getProgressBydDateController);
 router.get("/range", validateGetRangeProgressRecordsParams, getProgressRangeData);
 
 module.exports = router;

utils/progresses.js

@@ -178,6 +178,27 @@ const getProgressRecords = async (query, queryParams) => {
   return progressRecords;
 };
 
+/**
+ * Retrieves progress records for a given date range.
+ * @param {Object} pathParamsObject - An object containing the type , typeId and date.
+ * @param {string} pathParamsObject.type - The type of the record i.e user or task.
+ * @param {string} pathParamsObject.typeId - The id of the type i.e user or task.
+ * @param {string} pathParamsObject.date - The date of the record
+ * @returns {Query} A Firestore query object that filters progress documents based on the given parameters.
+ *
+ */
+const buildQueryToSearchProgressByDay = (pathParams) => {
+  const { userId, taskId, date } = pathParams;
+  let query = progressesCollection;
+  if (userId) {
+    query = query.where("userId", "==", userId);
+  } else {
+    query = query.where("taskId", "==", taskId);
+  }
+  const dateTimeStamp = new Date(date).setUTCHours(0, 0, 0, 0);
+  query = query.where("date", "==", dateTimeStamp).limit(1);
+  return query;
+};
 module.exports = {
   getProgressDateTimestamp,
   buildQueryForPostingProgress,
@@ -188,4 +209,5 @@ module.exports = {
   getProgressDocs,
   buildRangeProgressQuery,
   getProgressRecords,
+  buildQueryToSearchProgressByDay,
 };