first version of the averages API

src/device-registry/controllers/create-event.js

@@ -938,6 +938,58 @@
       return;
     }
   },
+  listReadingAverages: async (req, res, next) => {
+    try {
+      const errors = extractErrorsFromRequest(req);
+      if (errors) {
+        next(
+          new HttpError("bad request errors", httpStatus.BAD_REQUEST, errors)
+        );
+        return;
+      }
+
+      const request = {
+        ...req,
+        query: {
+          ...req.query,
+          tenant: isEmpty(req.query.tenant) ? "airqo" : req.query.tenant,
+          averages: "readings",
+        },
+      };
+
+      const result = await createEventUtil.listReadingAverages(request, next);
+
+      if (isEmpty(result) || res.headersSent) {
+        return;
+      }
+
+      const status = result.status || httpStatus.OK;
+      if (result.success === true) {
+        res.status(status).json({
+          success: true,
+          message: result.message,
+          measurements: result.data,
+        });
+      } else {
+        const errorStatus = result.status || httpStatus.INTERNAL_SERVER_ERROR;
+        res.status(errorStatus).json({
+          success: false,
+          errors: result.errors || { message: "" },
+          message: result.message,
+        });
+      }
+    } catch (error) {
+      logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+      next(
+        new HttpError(
+          "Internal Server Error",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+      return;
+    }
+  },
   signalsForMap: async (req, res, next) => {
     try {
       logText("the signals for the AirQo Map...");
@@ -1195,6 +1247,90 @@
       return;
     }
   },
+  listAverages: async (req, res, next) => {
+    try {
+      const errors = extractErrorsFromRequest(req);
+      if (errors) {
+        next(
+          new HttpError("bad request errors", httpStatus.BAD_REQUEST, errors)
+        );
+        return;
+      }
+
+      const request = req;
+      const defaultTenant = constants.DEFAULT_TENANT || "airqo";
+      request.query.tenant = isEmpty(req.query.tenant)
+        ? defaultTenant
+        : req.query.tenant;
+
+      request.query.recent = "no";
+      request.query.metadata = "site_id";
+      request.query.averages = "events";
+      request.query.brief = "yes";
+      const { cohort_id, grid_id } = { ...req.query, ...req.params };
+
+      let locationErrors = 0;
+
+      if (cohort_id) {
+        await processCohortIds(cohort_id, request);
+        if (isEmpty(request.query.device_id)) {
+          locationErrors++;
+        }
+      } else if (grid_id) {
+        await processGridIds(grid_id, request);
+        if (isEmpty(request.query.site_id)) {
+          locationErrors++;
+        }
+      }
+
+      if (locationErrors === 0) {
+        const result = await createEventUtil.listAverages(request, next);
+
+        if (isEmpty(result) || res.headersSent) {
+          return;
+        }
+
+        if (result.success === true) {
+          const status = result.status ? result.status : httpStatus.OK;
+
+          res.status(status).json({
+            success: true,
+            isCache: result.isCache,
+            message: result.message,
+            measurements: result.data,
+          });
+        } else if (result.success === false) {
+          const status = result.status
+            ? result.status
+            : httpStatus.INTERNAL_SERVER_ERROR;
+          const errors = result.errors ? result.errors : { message: "" };
+          res.status(status).json({
+            success: false,
+            errors,
+            message: result.message,
+          });
+        }
+      } else {
+        res.status(httpStatus.BAD_REQUEST).json({
+          success: false,
+          errors: {
+            message: `Unable to process measurements for the provided measurement IDs`,
+          },
+          message: "Bad Request",
+        });
+      }
+    } catch (error) {
+      logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+      next(
+        new HttpError(
+          "Internal Server Error",
+          httpStatus.INTERNAL_SERVER_ERROR,
+          { message: error.message }
+        )
+      );
+      return;
+    }
+  },
   listHistorical: async (req, res, next) => {
     try {
       const errors = extractErrorsFromRequest(req);

src/device-registry/models/Event.js

@@ -2541,6 +2541,135 @@
   }
 };
 
+eventSchema.statics.getAirQualityAverages = async function(siteId, next) {
+  try {
+    // Get current date and date 2 weeks ago
+    const now = new Date();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const twoWeeksAgo = new Date(today);
+    twoWeeksAgo.setDate(today.getDate() - 14);
+
+    // Base query to match site and time range
+    const baseMatch = {
+      "values.site_id": mongoose.Types.ObjectId(siteId),
+      "values.time": {
+        $gte: twoWeeksAgo,
+        $lte: now,
+      },
+    };
+
+    const result = await this.aggregate([
+      // Unwind the values array to work with individual readings
+      { $unwind: "$values" },
+
+      // Match site and time range
+      { $match: baseMatch },
+
+      // Project only needed fields and add date fields for grouping
+      {
+        $project: {
+          time: "$values.time",
+          pm2_5: "$values.pm2_5.value",
+          dayOfYear: { $dayOfYear: "$values.time" },
+          year: { $year: "$values.time" },
+          week: { $week: "$values.time" },
+        },
+      },
+
+      // Group by day to get daily averages
+      {
+        $group: {
+          _id: {
+            year: "$year",
+            dayOfYear: "$dayOfYear",
+          },
+          dailyAverage: { $avg: "$pm2_5" },
+          date: { $first: "$time" },
+          week: { $first: "$week" },
+        },
+      },
+
+      // Sort by date
+      { $sort: { date: -1 } },
+
+      // Group again to calculate weekly averages
+      {
+        $group: {
+          _id: "$week",
+          weeklyAverage: { $avg: "$dailyAverage" },
+          days: {
+            $push: {
+              date: "$date",
+              average: "$dailyAverage",
+            },
+          },
+        },
+      },
+
+      // Sort by week
+      { $sort: { _id: -1 } },
+
+      // Limit to get only last 2 weeks
+      { $limit: 2 },
+    ]).allowDiskUse(true);
+
+    // If we don't have enough data
+    if (result.length < 2) {
+      return {
+        success: false,
+        message: "Insufficient data for comparison",
+        status: httpStatus.NOT_FOUND,
+      };
+    }
+
+    // Get current week and previous week data
+    const currentWeek = result[0];
+    const previousWeek = result[1];
+
+    // Calculate percentage difference
+
+    const percentageDifference =
+      previousWeek.weeklyAverage !== 0
+        ? ((currentWeek.weeklyAverage - previousWeek.weeklyAverage) /
+            previousWeek.weeklyAverage) *
+          100
+        : 0;
+
+    // Get today's date string in YYYY-MM-DD format
+    const todayStr = today.toISOString().split("T")[0];
+
+    // Find today's average from the current week's days
+    const todayAverage =
+      currentWeek.days.find(
+        (day) => day.date.toISOString().split("T")[0] === todayStr
+      )?.average || null;
+
+    return {
+      success: true,
+      data: {
+        dailyAverage: todayAverage ? parseFloat(todayAverage.toFixed(2)) : null,
+        percentageDifference: parseFloat(percentageDifference.toFixed(2)),
+        weeklyAverages: {
+          currentWeek: parseFloat(currentWeek.weeklyAverage.toFixed(2)),
+          previousWeek: parseFloat(previousWeek.weeklyAverage.toFixed(2)),
+        },
+      },
+      message: "Successfully retrieved air quality averages",
+      status: httpStatus.OK,
+    };
+  } catch (error) {
+    logger.error(
+      `Internal Server Error --- getAirQualityAverages --- ${error.message}`
+    );
+    logObject("error", error);
+    next(
+      new HttpError("Internal Server Error", httpStatus.INTERNAL_SERVER_ERROR, {
+        message: error.message,
+      })
+    );
+  }
+};
+
 const eventsModel = (tenant) => {
   try {
     const events = mongoose.model("events");