|
diff --git a/src/auth-service/utils/generate-filter.js b/src/auth-service/utils/generate-filter.js
index 549f1e7df4..1e2f668898 100644
--- a/src/auth-service/utils/generate-filter.js
+++ b/src/auth-service/utils/generate-filter.js
@@ -13,6 +13,7 @@ const { HttpError } = require("@utils/errors");
const {
addMonthsToProvideDateTime,
monthsInfront,
+ addMonthsToProvidedDate,
isTimeEmpty,
getDifferenceInMonths,
addDays,
@@ -788,6 +789,7 @@ const filter = {
const { service, startTime, endTime, email } = req.query;
const today = monthsInfront(0, next);
const oneWeekBack = addDays(-7, next);
+ logObject("the req.query in the logs filter", req.query);
let filter = {
timestamp: {
@@ -810,11 +812,13 @@ const filter = {
next
);
} else {
- delete filter["timestamp"];
+ filter["timestamp"]["$lte"] = addMonthsToProvidedDate(
+ startTime,
+ 1,
+ next
+ );
}
- }
-
- if (endTime && isEmpty(startTime)) {
+ } else if (endTime && isEmpty(startTime)) {
logText("startTime absent and endTime is present");
if (isTimeEmpty(endTime) === false) {
filter["timestamp"]["$lte"] = addMonthsToProvideDateTime(
@@ -823,25 +827,16 @@ const filter = {
next
);
} else {
- delete filter["timestamp"];
+ filter["timestamp"]["$lte"] = addMonthsToProvidedDate(
+ endTime,
+ -1,
+ next
+ );
}
- }
-
- if (endTime && startTime) {
+ } else if (endTime && startTime) {
logText("startTime present and endTime is also present");
- let months = getDifferenceInMonths(startTime, endTime);
- logElement("the number of months", months);
- if (months > 1) {
- if (isTimeEmpty(endTime) === false) {
- filter["timestamp"]["$lte"] = addMonthsToProvideDateTime(
- endTime,
- -1,
- next
- );
- } else {
- delete filter["timestamp"];
- }
- }
+ filter["timestamp"]["$lte"] = new Date(endTime);
+ filter["timestamp"]["$gte"] = new Date(startTime);
}
if (email) {
@@ -861,6 +856,102 @@ const filter = {
);
}
},
+ activities: (req, next) => {
+ try {
+ const { service, startTime, endTime, email, tenant } = req.query;
+ const today = monthsInfront(0, next);
+ const oneWeekBack = addDays(-7, next);
+
+ logObject("the req.query in the activity filter", req.query);
+
+ // Base filter
+ let filter = {};
+
+ // Handle required tenant field
+ if (!tenant) {
+ throw new Error("Tenant is required");
+ }
+ filter.tenant = tenant;
+
+ // Handle email filtering
+ if (email) {
+ logText("email present");
+ filter.email = email;
+ }
+
+ // Date range handling for dailyStats
+ let dateFilter = {};
+ if (startTime && !endTime) {
+ logText("startTime present and endTime is missing");
+ if (!isTimeEmpty(startTime)) {
+ dateFilter.$gte = addMonthsToProvideDateTime(startTime, 1, next);
+ } else {
+ dateFilter.$gte = addMonthsToProvidedDate(startTime, 1, next);
+ }
+ } else if (endTime && !startTime) {
+ logText("startTime absent and endTime is present");
+ if (!isTimeEmpty(endTime)) {
+ dateFilter.$lte = addMonthsToProvideDateTime(endTime, -1, next);
+ } else {
+ dateFilter.$lte = addMonthsToProvidedDate(endTime, -1, next);
+ }
+ } else if (endTime && startTime) {
+ logText("startTime present and endTime is also present");
+ dateFilter.$lte = new Date(endTime);
+ dateFilter.$gte = new Date(startTime);
+ } else {
+ // Default to one week range
+ dateFilter.$gte = oneWeekBack;
+ dateFilter.$lte = today;
+ }
+
+ // Apply date filter to dailyStats
+ if (Object.keys(dateFilter).length > 0) {
+ filter["dailyStats"] = {
+ $elemMatch: {
+ date: dateFilter,
+ },
+ };
+ }
+
+ // Service filtering
+ if (service) {
+ logText("service present");
+ // Add service filter to the dailyStats elemMatch
+ if (filter.dailyStats && filter.dailyStats.$elemMatch) {
+ filter.dailyStats.$elemMatch["services"] = {
+ $elemMatch: { name: service },
+ };
+ } else {
+ filter.dailyStats = {
+ $elemMatch: {
+ services: {
+ $elemMatch: { name: service },
+ },
+ },
+ };
+ }
+
+ // Also check monthly stats for the service
+ filter["monthlyStats"] = {
+ $elemMatch: {
+ uniqueServices: service,
+ },
+ };
+ }
+
+ return filter;
+ } catch (error) {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
favorites: (req, next) => {
try {
const { query, params } = req;
diff --git a/src/auth-service/utils/mailer.js b/src/auth-service/utils/mailer.js
index 8c9041efc2..ef5e2f5691 100644
--- a/src/auth-service/utils/mailer.js
+++ b/src/auth-service/utils/mailer.js
@@ -1,5 +1,5 @@
const transporter = require("@config/mailer");
-const { logObject } = require("@utils/log");
+const { logObject, logText } = require("@utils/log");
const isEmpty = require("is-empty");
const SubscriptionModel = require("@models/Subscription");
const constants = require("@config/constants");
@@ -284,6 +284,61 @@ const mailer = {
);
}
},
+ yearEndEmail: async ({
+ email = "",
+ firstName = "",
+ lastName = "",
+ tenant = "airqo",
+ userStat = {},
+ } = {}) => {
+ try {
+ const checkResult = await SubscriptionModel(
+ tenant
+ ).checkNotificationStatus({ email, type: "email" });
+
+ if (!checkResult.success) {
+ return checkResult;
+ }
+
+ const mailOptions = {
+ to: email,
+ from: {
+ name: constants.EMAIL_NAME,
+ address: constants.EMAIL,
+ },
+ subject: "Your AirQo Analytics 2024 Year in Review 🌍",
+ html: msgs.yearEndSummary(userStat),
+ attachments: attachments,
+ };
+
+ let response = transporter.sendMail(mailOptions);
+ let data = await response;
+
+ if (isEmpty(data.rejected) && !isEmpty(data.accepted)) {
+ return {
+ success: true,
+ message: "Year-end email successfully sent",
+ data,
+ status: httpStatus.OK,
+ };
+ } else {
+ return {
+ success: false,
+ message: "Internal Server Error",
+ status: httpStatus.INTERNAL_SERVER_ERROR,
+ errors: { message: "Email not sent", emailResults: data },
+ };
+ }
+ } catch (error) {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ return {
+ success: false,
+ message: "Internal Server Error",
+ status: httpStatus.INTERNAL_SERVER_ERROR,
+ errors: { message: error.message },
+ };
+ }
+ },
requestToJoinGroupByEmail: async (
{
email,
diff --git a/src/auth-service/validators/analytics.validators.js b/src/auth-service/validators/analytics.validators.js
new file mode 100644
index 0000000000..9123e36965
--- /dev/null
+++ b/src/auth-service/validators/analytics.validators.js
@@ -0,0 +1,169 @@
+const { query, body, param, oneOf } = require("express-validator");
+const constants = require("@config/constants");
+
+const validateTimeframe = query("timeframe")
+ .optional()
+ .isIn(["last7days", "last30days", "last90days", "custom"])
+ .withMessage("Invalid timeframe");
+
+const validateDateRange = [
+ query("startDate")
+ .if(query("timeframe").equals("custom"))
+ .isISO8601()
+ .withMessage("Start date required for custom timeframe"),
+ query("endDate")
+ .if(query("timeframe").equals("custom"))
+ .isISO8601()
+ .withMessage("End date required for custom timeframe"),
+];
+
+const validateUserEmail = param("email")
+ .isEmail()
+ .withMessage("Valid email is required");
+
+const validatePeriod = query("period")
+ .isIn(["daily", "weekly", "monthly", "quarterly", "yearly"])
+ .withMessage("Invalid period");
+
+const validateCohortPeriod = query("period")
+ .isIn(["daily", "weekly", "monthly"])
+ .withMessage("Invalid cohort period");
+
+const validateMetricType = query("metric")
+ .isIn(["engagement", "retention", "activity", "growth"])
+ .withMessage("Invalid metric type");
+
+const validateYearMonth = [
+ query("year").isInt().withMessage("Invalid year"),
+ query("month").isInt({ min: 0, max: 11 }).withMessage("Invalid month (0-11)"),
+];
+
+const validateGroupBy = query("groupBy")
+ .isIn(["service", "endpoint", "user"])
+ .withMessage("Invalid grouping parameter");
+
+const validateEmailsArray = body("emails")
+ .exists()
+ .withMessage("the emails array field must be provided in the request body")
+ .bail()
+ .isArray()
+ .withMessage("emails must be provided as an array")
+ .bail()
+ .notEmpty()
+ .withMessage("the provided emails array cannot be empty");
+
+// Grouped validation rules for different endpoints
+const userEngagementValidators = {
+ getEngagement: [validateUserEmail, validateTimeframe, ...validateDateRange],
+ getMetrics: [validateUserEmail, ...validateYearMonth],
+};
+
+const activityValidators = {
+ getReport: [validateUserEmail, validateTimeframe, ...validateDateRange],
+};
+
+const cohortValidators = {
+ getAnalysis: [
+ validateCohortPeriod,
+ query("metrics")
+ .optional()
+ .isArray()
+ .withMessage("Metrics must be an array"),
+ query("minCohortSize")
+ .optional()
+ .isInt({ min: 1 })
+ .withMessage("Invalid minimum cohort size"),
+ ],
+};
+
+const predictiveValidators = {
+ getPredictions: [
+ validateUserEmail,
+ query("includeChurnRisk")
+ .optional()
+ .isBoolean()
+ .withMessage("Invalid churn risk inclusion parameter"),
+ ],
+};
+
+const serviceAdoptionValidators = {
+ getAdoption: [
+ validateUserEmail,
+ query("includeRecommendations")
+ .optional()
+ .isBoolean()
+ .withMessage("Invalid recommendations parameter"),
+ ],
+};
+
+const benchmarkValidators = {
+ getBenchmarks: [validateMetricType, validatePeriod],
+};
+
+const topUsersValidators = {
+ getTopUsers: [
+ ...validateYearMonth,
+ query("limit")
+ .optional()
+ .isInt({ min: 1, max: 100 })
+ .withMessage("Invalid limit"),
+ validateMetricType.optional(),
+ ],
+};
+
+const aggregateValidators = {
+ getAggregated: [
+ query("startDate").isISO8601().withMessage("Invalid start date"),
+ query("endDate").isISO8601().withMessage("Invalid end date"),
+ validateGroupBy,
+ ],
+};
+
+const retentionValidators = {
+ getRetention: [
+ validateCohortPeriod.optional(),
+ query("period")
+ .isInt({ min: 1, max: 12 })
+ .withMessage("Invalid period range"),
+ ],
+};
+
+const healthScoreValidators = {
+ getHealthScore: [
+ validateUserEmail,
+ query("includeFactors")
+ .optional()
+ .isBoolean()
+ .withMessage("Invalid factors inclusion parameter"),
+ ],
+};
+
+const behaviorValidators = {
+ getBehavior: [
+ validateUserEmail,
+ query("includeSegmentation")
+ .optional()
+ .isBoolean()
+ .withMessage("Invalid segmentation parameter"),
+ ],
+};
+
+const emailValidators = {
+ sendEmails: [validateEmailsArray],
+ retrieveStats: [validateEmailsArray],
+};
+
+module.exports = {
+ userEngagementValidators,
+ activityValidators,
+ cohortValidators,
+ predictiveValidators,
+ serviceAdoptionValidators,
+ benchmarkValidators,
+ topUsersValidators,
+ aggregateValidators,
+ retentionValidators,
+ healthScoreValidators,
+ behaviorValidators,
+ emailValidators,
+};
diff --git a/src/device-registry/bin/jobs/kafka-consumer.js b/src/device-registry/bin/jobs/kafka-consumer.js
index b131908cf0..66022f64f4 100644
--- a/src/device-registry/bin/jobs/kafka-consumer.js
+++ b/src/device-registry/bin/jobs/kafka-consumer.js
@@ -5,13 +5,15 @@ const logger = log4js.getLogger(
`${constants.ENVIRONMENT} -- bin/jobs/kafka-consumer`
);
const { logObject } = require("@utils/log");
-const createEvent = require("@utils/create-event");
+const createEventUtil = require("@utils/create-event");
+const createForecastUtil = require("@utils/create-forecast");
const Joi = require("joi");
const { jsonrepair } = require("jsonrepair");
const cleanDeep = require("clean-deep");
const isEmpty = require("is-empty");
const stringify = require("@utils/stringify");
+// Existing measurement schema
const eventSchema = Joi.object({
s2_pm2_5: Joi.number().optional(),
s2_pm10: Joi.number().optional(),
@@ -62,6 +64,39 @@ const eventSchema = Joi.object({
intakehumidity: Joi.number().optional(),
}).unknown(true);
+// Forecast validation schemas
+const forecastMeasurementsSchema = Joi.object({
+ timestamp: Joi.date()
+ .iso()
+ .required(),
+ horizon: Joi.number().required(),
+ measurements: Joi.object({
+ pm2_5: Joi.number().required(),
+ pm10: Joi.number().required(),
+ confidence: Joi.object({
+ pm2_5_lower: Joi.number().required(),
+ pm2_5_upper: Joi.number().required(),
+ pm10_lower: Joi.number().required(),
+ pm10_upper: Joi.number().required(),
+ }).required(),
+ }).required(),
+});
+
+const forecastSchema = Joi.object({
+ type: Joi.string()
+ .valid("forecast")
+ .required(),
+ created_at: Joi.date()
+ .iso()
+ .required(),
+ model_version: Joi.string().required(),
+ device_id: Joi.string().required(),
+ site_id: Joi.string().required(),
+ forecasts: Joi.array()
+ .items(forecastMeasurementsSchema)
+ .required(),
+});
+
const eventsSchema = Joi.array().items(eventSchema);
const consumeHourlyMeasurements = async (messageData) => {
@@ -103,13 +138,16 @@ const consumeHourlyMeasurements = async (messageData) => {
timestamp,
};
});
+ logger.error(`Validation errors: ${stringify(errorDetails)}`);
}
const request = {
body: cleanedMeasurements,
};
- const responseFromInsertMeasurements = await createEvent.create(request);
+ const responseFromInsertMeasurements = await createEventUtil.create(
+ request
+ );
if (responseFromInsertMeasurements.success === false) {
console.log("KAFKA: failed to store the measurements");
@@ -122,6 +160,106 @@ const consumeHourlyMeasurements = async (messageData) => {
}
};
+// Transform the incoming forecast message to match the expected format
+const transformForecastData = (forecastData) => {
+ const {
+ forecasts,
+ created_at,
+ model_version,
+ device_id,
+ site_id,
+ } = forecastData;
+
+ // Transform the forecasts into the expected format
+ const values = forecasts.map((forecast) => ({
+ time: forecast.timestamp,
+ forecast_horizon: forecast.horizon,
+ pm2_5: {
+ value: forecast.measurements.pm2_5,
+ confidence_lower: forecast.measurements.confidence.pm2_5_lower,
+ confidence_upper: forecast.measurements.confidence.pm2_5_upper,
+ },
+ pm10: {
+ value: forecast.measurements.pm10,
+ confidence_lower: forecast.measurements.confidence.pm10_lower,
+ confidence_upper: forecast.measurements.confidence.pm10_upper,
+ },
+ }));
+
+ return {
+ device_id,
+ site_id,
+ forecast_created_at: created_at,
+ model_version,
+ values,
+ };
+};
+
+// New function to handle forecast messages
+const consumeForecasts = async (messageData) => {
+ try {
+ if (isEmpty(messageData)) {
+ logger.error(
+ `KAFKA: forecast message is undefined --- ${stringify(messageData)}`
+ );
+ return;
+ }
+
+ const repairedJSONString = jsonrepair(messageData);
+ const forecastData = JSON.parse(repairedJSONString);
+
+ // Validate the incoming forecast data against our schema
+ const options = {
+ abortEarly: false,
+ };
+
+ const { error, value } = forecastSchema.validate(forecastData, options);
+
+ if (error) {
+ const errorDetails = error.details.map((detail) => ({
+ message: detail.message,
+ key: detail.context.key,
+ path: detail.path.join("."),
+ }));
+ logger.error(`Forecast validation errors: ${stringify(errorDetails)}`);
+ return;
+ }
+
+ // Transform the validated data to match the expected format for createForecastUtil
+ const transformedData = transformForecastData(forecastData);
+
+ // Create the request object expected by createForecastUtil.create
+ const request = {
+ body: transformedData,
+ query: {
+ tenant: constants.DEFAULT_TENANT,
+ },
+ };
+
+ // Store the forecast using createForecastUtil
+ const response = await createForecastUtil.create(request, (error) => {
+ if (error) {
+ logger.error(`KAFKA: forecast creation error --- ${stringify(error)}`);
+ throw error;
+ }
+ });
+
+ if (response.success === false) {
+ logger.error(`KAFKA: failed to store forecasts --- ${response.message}`);
+ } else if (response.success === true) {
+ logger.info(
+ `KAFKA: successfully stored forecasts --- ${response.message}`
+ );
+ logger.info(`KAFKA: stored ${response.data.length} forecast days`);
+ }
+ } catch (error) {
+ logger.error(`🐛🐛 KAFKA: forecast error message --- ${error.message}`);
+ logger.error(
+ `🐛🐛 KAFKA: forecast full error object --- ${stringify(error)}`
+ );
+ }
+};
+
const kafkaConsumer = async () => {
try {
const kafka = new Kafka({
@@ -137,19 +275,20 @@ const kafkaConsumer = async () => {
// Define topic-to-operation function mapping
const topicOperations = {
- ["hourly-measurements-topic"]: consumeHourlyMeasurements,
+ "hourly-measurements-topic": consumeHourlyMeasurements,
+ "airqo.forecasts": consumeForecasts,
};
await consumer.connect();
- // First, subscribe to all topics
+ // Subscribe to all topics
await Promise.all(
Object.keys(topicOperations).map((topic) =>
consumer.subscribe({ topic, fromBeginning: false })
)
);
- // Then, start consuming messages
+ // Start consuming messages
await consumer.run({
eachMessage: async ({ topic, partition, message }) => {
try {
diff --git a/src/device-registry/controllers/create-event.js b/src/device-registry/controllers/create-event.js
index 5c1fb30951..0d8302504f 100644
--- a/src/device-registry/controllers/create-event.js
+++ b/src/device-registry/controllers/create-event.js
@@ -1267,6 +1267,8 @@ const createEvent = {
request.query.metadata = "site_id";
request.query.averages = "events";
request.query.brief = "yes";
+ request.query.quality_checks = "no";
+
const { cohort_id, grid_id } = { ...req.query, ...req.params };
let locationErrors = 0;
@@ -1331,6 +1333,92 @@ const createEvent = {
return;
}
},
+ listAveragesV2: 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";
+ request.query.quality_checks = "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.listAveragesV2(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);
diff --git a/src/device-registry/controllers/create-forecast.js b/src/device-registry/controllers/create-forecast.js
new file mode 100644
index 0000000000..2b9bf502e5
--- /dev/null
+++ b/src/device-registry/controllers/create-forecast.js
@@ -0,0 +1,108 @@
+const httpStatus = require("http-status");
+const { extractErrorsFromRequest, HttpError } = require("@utils/errors");
+const constants = require("@config/constants");
+const log4js = require("log4js");
+const logger = log4js.getLogger(
+ `${constants.ENVIRONMENT} -- forecast-controller`
+);
+const forecastUtil = require("@utils/create-forecast");
+const isEmpty = require("is-empty");
+
+const handleError = (error, next) => {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ next(
+ new HttpError("Internal Server Error", httpStatus.INTERNAL_SERVER_ERROR, {
+ message: error.message,
+ })
+ );
+};
+
+const validateRequest = (req, next) => {
+ const errors = extractErrorsFromRequest(req);
+ if (errors) {
+ next(new HttpError("bad request errors", httpStatus.BAD_REQUEST, errors));
+ return false;
+ }
+ return true;
+};
+
+const getTenantFromRequest = (req) => {
+ const defaultTenant = constants.DEFAULT_TENANT || "airqo";
+ return isEmpty(req.query.tenant) ? defaultTenant : req.query.tenant;
+};
+
+const sendResponse = (res, result) => {
+ if (result.success === true) {
+ const status = result.status || httpStatus.OK;
+ res.status(status).json({
+ success: true,
+ message: result.message,
+ [result.dataKey || "forecast"]: result.data || [],
+ });
+ } else {
+ const status = result.status || httpStatus.INTERNAL_SERVER_ERROR;
+ res.status(status).json({
+ success: false,
+ message: result.message,
+ errors: result.errors || { message: "" },
+ });
+ }
+};
+
+const handleControllerAction = async (
+ req,
+ res,
+ next,
+ utilFunction,
+ dataKey
+) => {
+ try {
+ if (!validateRequest(req, next)) return;
+
+ const request = req;
+ request.query.tenant = getTenantFromRequest(req);
+
+ const result = await utilFunction(request, next);
+
+ if (isEmpty(result) || res.headersSent) return;
+
+ result.dataKey = dataKey;
+ sendResponse(res, result);
+ } catch (error) {
+ handleError(error, next);
+ }
+};
+
+const forecastController = {
+ create: async (req, res, next) => {
+ await handleControllerAction(
+ req,
+ res,
+ next,
+ forecastUtil.create,
+ "forecast"
+ );
+ },
+
+ listByDevice: async (req, res, next) => {
+ await handleControllerAction(
+ req,
+ res,
+ next,
+ forecastUtil.listByDevice,
+ "forecasts"
+ );
+ },
+
+ listBySite: async (req, res, next) => {
+ await handleControllerAction(
+ req,
+ res,
+ next,
+ forecastUtil.listBySite,
+ "forecasts"
+ );
+ },
+};
+
+module.exports = forecastController;
diff --git a/src/device-registry/models/Event.js b/src/device-registry/models/Event.js
index 5e05cc2a3e..ddd63d39aa 100644
--- a/src/device-registry/models/Event.js
+++ b/src/device-registry/models/Event.js
@@ -2947,6 +2947,292 @@ eventSchema.statics.getAirQualityAverages = async function(siteId, next) {
}
};
+eventSchema.statics.v2_getAirQualityAverages = async function(siteId, next) {
+ try {
+ const TIMEZONE = "Africa/Kampala";
+ const MIN_READINGS_PER_DAY = 12; // Minimum readings per day for validity
+
+ const now = moment()
+ .tz(TIMEZONE)
+ .toDate();
+ const today = moment()
+ .tz(TIMEZONE)
+ .startOf("day")
+ .toDate();
+ const twoWeeksAgo = moment()
+ .tz(TIMEZONE)
+ .startOf("day")
+ .subtract(14, "days")
+ .toDate();
+
+ logText("Debug Info:");
+ logObject("TIMEZONE", TIMEZONE);
+ logObject("now", now);
+ logObject("today", today);
+ logObject("twoWeeksAgo", twoWeeksAgo);
+
+ const result = await this.aggregate([
+ // Initial match
+ {
+ $match: {
+ "values.site_id": mongoose.Types.ObjectId(siteId),
+ "values.time": { $gte: twoWeeksAgo, $lte: now },
+ },
+ },
+
+ // Unwind values
+ {
+ $unwind: {
+ path: "$values",
+ preserveNullAndEmptyArrays: false,
+ },
+ },
+
+ // Data quality filtering
+ {
+ $match: {
+ "values.time": { $gte: twoWeeksAgo, $lte: now },
+ "values.pm2_5.value": {
+ $exists: true,
+ $ne: null,
+ $gte: 0,
+ $lte: 1000,
+ },
+ },
+ },
+
+ // Project fields
+ {
+ $project: {
+ _id: 0,
+ time: "$values.time",
+ pm2_5: "$values.pm2_5.value",
+ yearWeek: {
+ $let: {
+ vars: {
+ dateParts: {
+ $dateToParts: {
+ date: "$values.time",
+ timezone: TIMEZONE,
+ iso8601: true,
+ },
+ },
+ },
+ in: {
+ $concat: [
+ { $toString: "$$dateParts.isoWeekYear" },
+ "-",
+ {
+ $cond: [
+ { $lt: ["$$dateParts.isoWeek", 10] },
+ { $concat: ["0", { $toString: "$$dateParts.isoWeek" }] },
+ { $toString: "$$dateParts.isoWeek" },
+ ],
+ },
+ ],
+ },
+ },
+ },
+ dayOfYear: {
+ $dateToString: {
+ format: "%Y-%m-%d",
+ date: "$values.time",
+ timezone: TIMEZONE,
+ },
+ },
+ hourOfDay: {
+ $hour: {
+ date: "$values.time",
+ timezone: TIMEZONE,
+ },
+ },
+ },
+ },
+
+ // Group by day with data quality metrics
+ {
+ $group: {
+ _id: "$dayOfYear",
+ dailyAverage: { $avg: "$pm2_5" },
+ readingCount: { $sum: 1 },
+ uniqueHours: { $addToSet: "$hourOfDay" },
+ yearWeek: { $first: "$yearWeek" },
+ minReading: { $min: "$pm2_5" },
+ maxReading: { $max: "$pm2_5" },
+ },
+ },
+
+ // Add data quality indicators
+ {
+ $addFields: {
+ dataQuality: {
+ hasMinReadings: { $gte: ["$readingCount", MIN_READINGS_PER_DAY] },
+ hoursCovered: { $size: "$uniqueHours" },
+ readingSpread: { $subtract: ["$maxReading", "$minReading"] },
+ },
+ },
+ },
+
+ // Group by week with quality metrics
+ {
+ $group: {
+ _id: "$yearWeek",
+ weeklyAverage: { $avg: "$dailyAverage" },
+ daysWithData: { $sum: 1 },
+ daysWithMinReadings: {
+ $sum: { $cond: ["$dataQuality.hasMinReadings", 1, 0] },
+ },
+ avgHoursCovered: { $avg: "$dataQuality.hoursCovered" },
+ days: {
+ $push: {
+ date: "$_id",
+ average: "$dailyAverage",
+ readingCount: "$readingCount",
+ hoursCovered: "$dataQuality.hoursCovered",
+ readingSpread: "$dataQuality.readingSpread",
+ },
+ },
+ },
+ },
+
+ // Sort and limit to 2 weeks
+ { $sort: { _id: -1 } },
+ { $limit: 2 },
+ ]).allowDiskUse(true);
+
+ if (result.length < 2) {
+ return {
+ success: false,
+ message: "Insufficient data for comparison",
+ status: httpStatus.NOT_FOUND,
+ };
+ }
+
+ const [currentWeek, previousWeek] = result;
+ const todayStr = moment(today)
+ .tz(TIMEZONE)
+ .format("YYYY-MM-DD");
+ const todayData = currentWeek.days.find((day) => day.date === todayStr);
+
+ // Calculate percentage difference without capping
+ const percentageDifference =
+ previousWeek.weeklyAverage !== 0
+ ? ((currentWeek.weeklyAverage - previousWeek.weeklyAverage) /
+ previousWeek.weeklyAverage) *
+ 100
+ : 0;
+
+ // Calculate data quality score
+ const dataQualityScore = calculateWeeklyDataQuality(
+ currentWeek,
+ previousWeek
+ );
+
+ return {
+ success: true,
+ data: {
+ dailyAverage: todayData
+ ? {
+ value: parseFloat(todayData.average.toFixed(2)),
+ readingCount: todayData.readingCount,
+ hoursCovered: todayData.hoursCovered,
+ }
+ : null,
+ percentageDifference: parseFloat(percentageDifference.toFixed(2)),
+ weeklyAverages: {
+ currentWeek: parseFloat(currentWeek.weeklyAverage.toFixed(2)),
+ previousWeek: parseFloat(previousWeek.weeklyAverage.toFixed(2)),
+ },
+ dataQuality: {
+ score: dataQualityScore,
+ currentWeek: {
+ daysWithData: currentWeek.daysWithData,
+ daysWithMinReadings: currentWeek.daysWithMinReadings,
+ averageHoursCovered: parseFloat(
+ currentWeek.avgHoursCovered.toFixed(1)
+ ),
+ },
+ previousWeek: {
+ daysWithData: previousWeek.daysWithData,
+ daysWithMinReadings: previousWeek.daysWithMinReadings,
+ averageHoursCovered: parseFloat(
+ previousWeek.avgHoursCovered.toFixed(1)
+ ),
+ },
+ warning:
+ dataQualityScore < 0.7
+ ? "Low data quality may affect accuracy of comparison"
+ : null,
+ },
+ },
+ 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,
+ })
+ );
+ }
+};
+
+function calculateWeeklyDataQuality(currentWeek, previousWeek) {
+ const IDEAL_DAYS = 7;
+ const IDEAL_HOURS = 24;
+
+ // Calculate scores for each week
+ const currentScore =
+ (currentWeek.daysWithMinReadings / IDEAL_DAYS) *
+ (currentWeek.avgHoursCovered / IDEAL_HOURS);
+
+ const previousScore =
+ (previousWeek.daysWithMinReadings / IDEAL_DAYS) *
+ (previousWeek.avgHoursCovered / IDEAL_HOURS);
+
+ // Return average score (0-1 range)
+ return (currentScore + previousScore) / 2;
+}
+
+// Helper function to calculate confidence score
+function calculateConfidenceScore(
+ currentWeek,
+ baselineWeeks,
+ minDataPointsPerDay
+) {
+ const maxPossibleReadings = 24; // Assuming hourly readings
+ const idealDaysPerWeek = 7;
+
+ // Score current week data completeness
+ const currentWeekScore =
+ (currentWeek.daysWithData / idealDaysPerWeek) *
+ (currentWeek.days.reduce(
+ (acc, day) => acc + day.readingCount / maxPossibleReadings,
+ 0
+ ) /
+ currentWeek.daysWithData);
+
+ // Score baseline weeks data completeness
+ const baselineScore =
+ baselineWeeks.reduce((acc, week) => {
+ const weekScore =
+ (week.daysWithData / idealDaysPerWeek) *
+ (week.days.reduce(
+ (acc, day) => acc + day.readingCount / maxPossibleReadings,
+ 0
+ ) /
+ week.daysWithData);
+ return acc + weekScore;
+ }, 0) / baselineWeeks.length;
+
+ // Combine scores (giving more weight to current week)
+ return (currentWeekScore * 0.6 + baselineScore * 0.4) * 100;
+}
+
const eventsModel = (tenant) => {
const defaultTenant = constants.DEFAULT_TENANT || "airqo";
const dbTenant = isEmpty(tenant) ? defaultTenant : tenant;
diff --git a/src/device-registry/models/Forecast.js b/src/device-registry/models/Forecast.js
new file mode 100644
index 0000000000..44565f6e9d
--- /dev/null
+++ b/src/device-registry/models/Forecast.js
@@ -0,0 +1,276 @@
+const mongoose = require("mongoose");
+const { Schema, model } = require("mongoose");
+const ObjectId = Schema.Types.ObjectId;
+const { logObject } = require("@utils/log");
+const httpStatus = require("http-status");
+const { HttpError } = require("@utils/errors");
+const isEmpty = require("is-empty");
+const constants = require("@config/constants");
+const { getModelByTenant } = require("@config/database");
+const log4js = require("log4js");
+const logger = log4js.getLogger(`${constants.ENVIRONMENT} -- forecast-model`);
+
+const forecastValueSchema = new Schema({
+ time: {
+ type: Date,
+ required: true,
+ },
+ forecast_created_at: {
+ type: Date,
+ required: true,
+ },
+ forecast_horizon: {
+ type: Number,
+ required: true,
+ },
+ device_id: {
+ type: ObjectId,
+ required: true,
+ },
+ site_id: {
+ type: ObjectId,
+ required: true,
+ },
+ pm2_5: {
+ value: { type: Number, default: null },
+ confidence_lower: { type: Number, default: null },
+ confidence_upper: { type: Number, default: null },
+ },
+ pm10: {
+ value: { type: Number, default: null },
+ confidence_lower: { type: Number, default: null },
+ confidence_upper: { type: Number, default: null },
+ },
+ model_version: {
+ type: String,
+ required: true,
+ },
+});
+
+const forecastSchema = new Schema(
+ {
+ day: {
+ type: String,
+ required: true,
+ },
+ device_id: {
+ type: ObjectId,
+ required: true,
+ },
+ site_id: {
+ type: ObjectId,
+ required: true,
+ },
+ first: {
+ type: Date,
+ required: true,
+ },
+ last: {
+ type: Date,
+ required: true,
+ },
+ values: [forecastValueSchema],
+ },
+ {
+ timestamps: true,
+ }
+);
+
+forecastSchema.methods = {
+ toJSON() {
+ return {
+ _id: this._id,
+ day: this.day,
+ device_id: this.device_id,
+ site_id: this.site_id,
+ first: this.first,
+ last: this.last,
+ values: this.values,
+ createdAt: this.createdAt,
+ updatedAt: this.updatedAt,
+ };
+ },
+};
+
+forecastSchema.index({ device_id: 1 });
+forecastSchema.index({ day: 1 });
+
+forecastSchema.statics = {
+ async register(args, next) {
+ try {
+ let createdForecast = await this.create(args);
+
+ if (!isEmpty(createdForecast)) {
+ let data = createdForecast._doc;
+ data.__v = undefined;
+ data.updatedAt = undefined;
+ return {
+ success: true,
+ data,
+ message: "Forecast created",
+ status: httpStatus.CREATED,
+ };
+ } else if (isEmpty(createdForecast)) {
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: "Forecast not created despite successful operation" }
+ )
+ );
+ }
+ } catch (error) {
+ logObject("the error", error);
+ let response = {};
+ let message = "validation errors for some of the provided fields";
+ let status = httpStatus.CONFLICT;
+ Object.entries(error.errors || {}).forEach(([key, value]) => {
+ response.message = value.message;
+ response[key] = value.message;
+ return response;
+ });
+
+ next(new HttpError(message, status, response));
+ }
+ },
+
+ async list({ skip = 0, limit = 100, filter = {} } = {}, next) {
+ try {
+ const response = await this.find(filter)
+ .sort({ createdAt: -1 })
+ .skip(skip)
+ .limit(limit)
+ .lean();
+
+ if (!isEmpty(response)) {
+ return {
+ success: true,
+ message: "successfully retrieved the forecasts",
+ data: response,
+ status: httpStatus.OK,
+ };
+ } else if (isEmpty(response)) {
+ return {
+ success: true,
+ message: "no forecasts exist, please crosscheck",
+ status: httpStatus.OK,
+ data: [],
+ };
+ }
+ } catch (error) {
+ logObject("the error", error);
+ const stringifiedMessage = JSON.stringify(error || "");
+ logger.error(`🐛🐛 Internal Server Error -- ${stringifiedMessage}`);
+
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
+
+ async modify({ filter = {}, update = {} } = {}, next) {
+ try {
+ let options = { new: true, useFindAndModify: false, upsert: false };
+
+ if (update._id) {
+ delete update._id;
+ }
+
+ const updatedForecast = await this.findOneAndUpdate(
+ filter,
+ update,
+ options
+ );
+
+ if (!isEmpty(updatedForecast)) {
+ return {
+ success: true,
+ message: "successfully modified the forecast",
+ data: updatedForecast._doc,
+ status: httpStatus.OK,
+ };
+ } else if (isEmpty(updatedForecast)) {
+ next(
+ new HttpError("Bad Request Error", httpStatus.BAD_REQUEST, {
+ ...filter,
+ message: "forecast does not exist, please crosscheck",
+ })
+ );
+ }
+ } catch (error) {
+ logObject("the error", error);
+ const stringifiedMessage = JSON.stringify(error || "");
+ logger.error(`🐛🐛 Internal Server Error -- ${stringifiedMessage}`);
+
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
+
+ async remove({ filter = {} } = {}, next) {
+ try {
+ let options = {
+ projection: {
+ _id: 1,
+ day: 1,
+ device_id: 1,
+ site_id: 1,
+ first: 1,
+ last: 1,
+ values: 1,
+ },
+ };
+ let removedForecast = await this.findOneAndRemove(filter, options).exec();
+
+ if (!isEmpty(removedForecast)) {
+ return {
+ success: true,
+ message: "successfully removed the forecast",
+ data: removedForecast._doc,
+ status: httpStatus.OK,
+ };
+ } else if (isEmpty(removedForecast)) {
+ next(
+ new HttpError("Bad Request Error", httpStatus.BAD_REQUEST, {
+ ...filter,
+ message: "forecast does not exist, please crosscheck",
+ })
+ );
+ }
+ } catch (error) {
+ logObject("the error", error);
+ const stringifiedMessage = JSON.stringify(error || "");
+ logger.error(`🐛🐛 Internal Server Error -- ${stringifiedMessage}`);
+
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
+};
+
+const ForecastModel = (tenant) => {
+ const defaultTenant = constants.DEFAULT_TENANT || "airqo";
+ const dbTenant = isEmpty(tenant) ? defaultTenant : tenant;
+ try {
+ const forecasts = mongoose.model("forecasts");
+ return forecasts;
+ } catch (errors) {
+ return getModelByTenant(dbTenant.toLowerCase(), "forecast", forecastSchema);
+ }
+};
+
+module.exports = ForecastModel;
diff --git a/src/device-registry/models/HealthTips.js b/src/device-registry/models/HealthTips.js
index 8466262b10..025b1b09dd 100644
--- a/src/device-registry/models/HealthTips.js
+++ b/src/device-registry/models/HealthTips.js
@@ -197,54 +197,7 @@ tipsSchema.statics = {
},
async modify({ filter = {}, update = {}, opts = { new: true } } = {}, next) {
try {
- logObject("the filter in the model", filter);
- logObject("the update in the model", update);
- logObject("the opts in the model", opts);
- let modifiedUpdateBody = Object.assign({}, update);
- if (modifiedUpdateBody._id) {
- delete modifiedUpdateBody._id;
- }
-
- delete modifiedUpdateBody.aqi_category;
-
- switch (update.aqi_category) {
- case "good":
- modifiedUpdateBody.aqi_category = { min: 0, max: 12.09 };
- break;
- case "moderate":
- modifiedUpdateBody.aqi_category = { min: 12.1, max: 35.49 };
- break;
- case "u4sg":
- modifiedUpdateBody.aqi_category = { min: 35.5, max: 55.49 };
- break;
- case "unhealthy":
- modifiedUpdateBody.aqi_category = { min: 55.5, max: 150.49 };
- break;
- case "very_unhealthy":
- modifiedUpdateBody.aqi_category = { min: 150.5, max: 250.49 };
- break;
- case "hazardous":
- modifiedUpdateBody.aqi_category = { min: 250.5, max: 500 };
- break;
- default:
- }
-
- let options = opts;
- let keys = {};
- const setProjection = (object) => {
- Object.keys(object).forEach((element) => {
- keys[element] = 1;
- });
- return keys;
- };
- logObject("the new modifiedUpdateBody", modifiedUpdateBody);
-
- const updatedTip = await this.findOneAndUpdate(
- filter,
- modifiedUpdateBody,
- options
- );
- logObject("updatedTip", updatedTip);
+ const updatedTip = await this.findOneAndUpdate(filter, update, opts);
if (!isEmpty(updatedTip)) {
return {
success: true,
diff --git a/src/device-registry/routes/v2/forecasts.js b/src/device-registry/routes/v2/forecasts.js
new file mode 100644
index 0000000000..e363e12599
--- /dev/null
+++ b/src/device-registry/routes/v2/forecasts.js
@@ -0,0 +1,50 @@
+const express = require("express");
+const router = express.Router();
+const forecastController = require("@controllers/create-forecast");
+const forecastValidations = require("@validators/forecast.validators");
+const { oneOf } = require("express-validator");
+
+const validatePagination = (req, res, next) => {
+ let limit = parseInt(req.query.limit, 10);
+ const skip = parseInt(req.query.skip, 10);
+ if (Number.isNaN(limit) || limit < 1) {
+ limit = 1000;
+ }
+ if (limit > 2000) {
+ limit = 2000;
+ }
+ if (Number.isNaN(skip) || skip < 0) {
+ req.query.skip = 0;
+ }
+ req.query.limit = limit;
+
+ next();
+};
+
+const headers = (req, res, next) => {
+ res.setHeader("Access-Control-Allow-Origin", "*");
+ res.header(
+ "Access-Control-Allow-Headers",
+ "Origin, X-Requested-With, Content-Type, Accept, Authorization"
+ );
+ res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
+ next();
+};
+
+router.use(headers);
+router.use(validatePagination);
+
+/******************* forecasts use-case ***************/
+router.post("/", oneOf(forecastValidations.create), forecastController.create);
+router.get(
+ "/devices/:deviceId",
+ oneOf(forecastValidations.listByDevice),
+ forecastController.listByDevice
+);
+router.get(
+ "/sites/:siteId",
+ oneOf(forecastValidations.listBySite),
+ forecastController.listBySite
+);
+
+module.exports = router;
diff --git a/src/device-registry/routes/v2/index.js b/src/device-registry/routes/v2/index.js
index ef1ec99c7a..f61d15a923 100644
--- a/src/device-registry/routes/v2/index.js
+++ b/src/device-registry/routes/v2/index.js
@@ -11,6 +11,7 @@ router.use("/measurements", require("@routes/v2/measurements"));
router.use("/signals", require("@routes/v2/signals"));
router.use("/locations", require("@routes/v2/locations"));
router.use("/photos", require("@routes/v2/photos"));
+router.use("/forecasts", require("@routes/v2/forecasts"));
router.use("/tips", require("@routes/v2/tips"));
router.use("/kya", require("@routes/v2/kya"));
router.use("/cohorts", require("@routes/v2/cohorts"));
diff --git a/src/device-registry/routes/v2/measurements.js b/src/device-registry/routes/v2/measurements.js
index cdab50de56..4506681999 100644
--- a/src/device-registry/routes/v2/measurements.js
+++ b/src/device-registry/routes/v2/measurements.js
@@ -1328,6 +1328,136 @@ router.get(
averagesLimiter,
eventController.listAverages
);
+
+/**
+ * @route GET /sites/:site_id/averages
+ * @description Get average measurements for a specific site
+ * @param {string} site_id - MongoDB ObjectId of the site
+ * @query {string} [tenant] - Optional tenant identifier
+ * @query {string} [startTime] - ISO8601 start time
+ * @query {string} [endTime] - ISO8601 end time
+ * @query {string} [frequency] - Data frequency (hourly|daily|raw|minute)
+ * @returns {object} Average measurements data
+ */
+router.get(
+ "/sites/:site_id/v2-averages",
+ oneOf([
+ query("tenant")
+ .optional()
+ .notEmpty()
+ .withMessage("tenant should not be empty if provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(constants.NETWORKS)
+ .withMessage("the tenant value is not among the expected ones"),
+ ]),
+ oneOf([
+ [
+ param("site_id")
+ .exists()
+ .withMessage("the site_id should be provided")
+ .bail()
+ .notEmpty()
+ .withMessage("the provided site_id cannot be empty")
+ .bail()
+ .trim()
+ .isMongoId()
+ .withMessage("the site_id must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ ],
+ ]),
+ oneOf([
+ [
+ query("startTime")
+ .optional()
+ .notEmpty()
+ .withMessage("startTime cannot be empty IF provided")
+ .bail()
+ .trim()
+ .isISO8601({ strict: true, strictSeparator: true })
+ .withMessage("startTime must be a valid datetime."),
+ query("endTime")
+ .optional()
+ .notEmpty()
+ .withMessage("endTime cannot be empty IF provided")
+ .bail()
+ .trim()
+ .isISO8601({ strict: true, strictSeparator: true })
+ .withMessage("endTime must be a valid datetime."),
+ query("frequency")
+ .optional()
+ .notEmpty()
+ .withMessage("the frequency cannot be empty if provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(["hourly", "daily", "raw", "minute"])
+ .withMessage(
+ "the frequency value is not among the expected ones which include: hourly, daily, minute and raw"
+ ),
+ query("format")
+ .optional()
+ .notEmpty()
+ .withMessage("the format cannot be empty if provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(["json", "csv"])
+ .withMessage(
+ "the format value is not among the expected ones which include: csv and json"
+ ),
+ query("external")
+ .optional()
+ .notEmpty()
+ .withMessage("external cannot be empty IF provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(["yes", "no"])
+ .withMessage(
+ "the external value is not among the expected ones which include: no and yes"
+ ),
+ query("recent")
+ .optional()
+ .notEmpty()
+ .withMessage("recent cannot be empty IF provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(["yes", "no"])
+ .withMessage(
+ "the recent value is not among the expected ones which include: no and yes"
+ ),
+ query("metadata")
+ .optional()
+ .notEmpty()
+ .withMessage("metadata cannot be empty IF provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(["site", "site_id", "device", "device_id"])
+ .withMessage(
+ "valid values include: site, site_id, device and device_id"
+ ),
+ query("test")
+ .optional()
+ .notEmpty()
+ .withMessage("test cannot be empty IF provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(["yes", "no"])
+ .withMessage("valid values include: YES and NO"),
+ ],
+ ]),
+ averagesLimiter,
+ eventController.listAveragesV2
+);
+
router.get(
"/sites/:site_id",
oneOf([
diff --git a/src/device-registry/routes/v2/tips.js b/src/device-registry/routes/v2/tips.js
index df56513a4d..5f8cc34890 100644
--- a/src/device-registry/routes/v2/tips.js
+++ b/src/device-registry/routes/v2/tips.js
@@ -1,24 +1,8 @@
const express = require("express");
const router = express.Router();
const healthTipController = require("@controllers/create-health-tips");
-const { check, oneOf, query, body, param } = require("express-validator");
-const constants = require("@config/constants");
-const mongoose = require("mongoose");
-const ObjectId = mongoose.Types.ObjectId;
-const { logElement, logText, logObject } = require("@utils/log");
-const isEmpty = require("is-empty");
-const NetworkModel = require("@models/Network");
-const validNetworks = async () => {
- const networks = await NetworkModel("airqo").distinct("name");
- return networks.map((network) => network.toLowerCase());
-};
-
-const validateNetwork = async (value) => {
- const networks = await validNetworks();
- if (!networks.includes(value.toLowerCase())) {
- throw new Error("Invalid network");
- }
-};
+const healthTipValidations = require("@validators/tips.validators");
+const { oneOf } = require("express-validator");
const validatePagination = (req, res, next) => {
let limit = parseInt(req.query.limit, 10);
@@ -46,202 +30,21 @@ const headers = (req, res, next) => {
res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
next();
};
+
router.use(headers);
router.use(validatePagination);
/******************* create-health-tip use-case ***************/
-router.get(
- "/",
- oneOf([
- [
- query("tenant")
- .optional()
- .notEmpty()
- .withMessage("the tenant cannot be empty, if provided")
- .bail()
- .trim()
- .toLowerCase()
- .isIn(constants.NETWORKS)
- .withMessage("the tenant value is not among the expected ones"),
- ],
- ]),
- oneOf([
- [
- query("id")
- .optional()
- .notEmpty()
- .withMessage("this tip identifier cannot be empty")
- .bail()
- .trim()
- .isMongoId()
- .withMessage("id must be an object ID")
- .bail()
- .customSanitizer((value) => {
- return ObjectId(value);
- }),
- ],
- ]),
- oneOf([
- [
- query("language")
- .optional()
- .notEmpty()
- .withMessage("the language cannot be empty when provided")
- .bail()
- .trim(),
- ],
- ]),
- healthTipController.list
-);
+router.get("/", oneOf(healthTipValidations.list), healthTipController.list);
router.post(
"/",
- oneOf([
- [
- query("tenant")
- .optional()
- .notEmpty()
- .withMessage("the tenant cannot be empty, if provided")
- .bail()
- .trim()
- .toLowerCase()
- .isIn(constants.NETWORKS)
- .withMessage("the tenant value is not among the expected ones"),
- ],
- ]),
- oneOf([
- [
- body("description")
- .exists()
- .withMessage("the description is missing in request")
- .bail()
- .trim(),
- body("title")
- .exists()
- .withMessage("the title is missing in request")
- .bail()
- .trim(),
- body("image")
- .exists()
- .withMessage("the image is missing in request")
- .bail()
- .trim(),
- body("aqi_category")
- .exists()
- .withMessage("the aqi_category is missing in request")
- .bail()
- .trim()
- .toLowerCase()
- .isIn(constants.AQI_CATEGORIES)
- .withMessage(
- "the aqi_category is not among the expected ones: good,moderate,u4sg,unhealthy,very_unhealthy,hazardous"
- ),
- ],
- ]),
+ oneOf(healthTipValidations.create),
healthTipController.create
);
-router.put(
- "/",
- oneOf([
- [
- query("tenant")
- .optional()
- .notEmpty()
- .withMessage("the tenant cannot be empty, if provided")
- .bail()
- .trim()
- .toLowerCase()
- .isIn(constants.NETWORKS)
- .withMessage("the tenant value is not among the expected ones"),
- ],
- ]),
- oneOf([
- query("id")
- .exists()
- .withMessage(
- "the tip unique identifier is missing in request, consider using the id"
- )
- .bail()
- .trim()
- .isMongoId()
- .withMessage("id must be an object ID")
- .bail()
- .customSanitizer((value) => {
- return ObjectId(value);
- }),
- ]),
- oneOf([
- body()
- .notEmpty()
- .custom((value) => {
- return !isEmpty(value);
- })
- .withMessage("the request body should not be empty"),
- ]),
- oneOf([
- [
- body("description")
- .optional()
- .notEmpty()
- .withMessage("the description is missing in request")
- .bail()
- .trim(),
- body("title")
- .optional()
- .notEmpty()
- .withMessage("the title is missing in request")
- .bail()
- .trim(),
- body("image")
- .optional()
- .notEmpty()
- .withMessage("the image is missing in request")
- .bail()
- .trim(),
- body("aqi_category")
- .optional()
- .notEmpty()
- .withMessage("the aqi_category is missing in request")
- .bail()
- .trim()
- .toLowerCase()
- .isIn(constants.AQI_CATEGORIES)
- .withMessage(
- "the aqi_category is not among the expected ones: good,moderate,u4sg,unhealthy,very_unhealthy,hazardous"
- ),
- ],
- ]),
- healthTipController.update
-);
+router.put("/", oneOf(healthTipValidations.update), healthTipController.update);
router.delete(
"/",
- oneOf([
- [
- query("tenant")
- .optional()
- .notEmpty()
- .withMessage("tenant should not be empty if provided")
- .bail()
- .trim()
- .toLowerCase()
- .isIn(constants.NETWORKS)
- .withMessage("the tenant value is not among the expected ones"),
- ],
- ]),
- oneOf([
- query("id")
- .exists()
- .withMessage(
- "the tip identifier is missing in request, consider using the id"
- )
- .bail()
- .trim()
- .isMongoId()
- .withMessage("the id must be an object ID")
- .bail()
- .customSanitizer((value) => {
- return ObjectId(value);
- }),
- ]),
+ oneOf(healthTipValidations.delete),
healthTipController.delete
);
diff --git a/src/device-registry/utils/create-airqloud.js b/src/device-registry/utils/create-airqloud.js
index 41788f079b..6f69c1f394 100644
--- a/src/device-registry/utils/create-airqloud.js
+++ b/src/device-registry/utils/create-airqloud.js
@@ -203,6 +203,14 @@ const createAirqloud = {
},
retrieveCoordinates: async (request, entity, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
let entityInstance = {};
if (entity === "location") {
entityInstance = createLocationUtil;
@@ -264,6 +272,14 @@ const createAirqloud = {
},
create: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
const { body, query } = request;
const { tenant } = query;
const { location_id } = body;
@@ -358,6 +374,14 @@ const createAirqloud = {
},
update: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
let { query, body } = request;
let { tenant } = query;
@@ -385,6 +409,14 @@ const createAirqloud = {
},
delete: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
let { query } = request;
let { tenant } = query;
let filter = generateFilter.airqlouds(request, next);
@@ -409,6 +441,14 @@ const createAirqloud = {
},
refresh: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
const { query, body } = request;
const { tenant, id, name, admin_level } = query;
@@ -490,6 +530,14 @@ const createAirqloud = {
},
calculateGeographicalCenter: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
const { body, query } = request;
const { coordinates } = body;
const { id } = query;
@@ -547,6 +595,14 @@ const createAirqloud = {
},
findSites: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
const { query, body } = request;
const { id, tenant, name, admin_level } = query;
let filter = {};
@@ -658,6 +714,14 @@ const createAirqloud = {
},
list: async (request, next) => {
try {
+ return {
+ success: false,
+ message: "Deprecated Functionality",
+ status: httpStatus.GONE,
+ errors: {
+ message: "Please use Grids or Cohorts, AirQlouds are deprecated",
+ },
+ };
const { tenant, limit, skip, path } = request.query;
const filter = generateFilter.airqlouds(request, next);
if (!isEmpty(path)) {
diff --git a/src/device-registry/utils/create-event.js b/src/device-registry/utils/create-event.js
index e566c253e8..88068e5dcb 100644
--- a/src/device-registry/utils/create-event.js
+++ b/src/device-registry/utils/create-event.js
@@ -320,6 +320,135 @@ async function processEvents(events, next) {
return determineResponse(nAdded, eventsAdded, eventsRejected, errors);
}
+class AirQualityService {
+ constructor(tenant) {
+ this.EventModel = EventModel(tenant);
+ }
+
+ async getAirQualityData(request, next, version = "v1") {
+ const { language, site_id } = { ...request.query, ...request.params };
+ let responseFromListEvents;
+
+ try {
+ // Try to get from cache first
+ const cacheResult = await this.tryGetCache(request, next);
+ if (cacheResult.success) {
+ return cacheResult.data;
+ }
+
+ // Get data based on version
+ responseFromListEvents =
+ version === "v2"
+ ? await this.EventModel.v2_getAirQualityAverages(site_id, next)
+ : await this.EventModel.getAirQualityAverages(site_id, next);
+
+ // Handle translation if needed (only for v1 as v2 doesn't include health tips)
+ if (version === "v1") {
+ await this.translateHealthTips(responseFromListEvents, language, next);
+ }
+
+ // Set cache if successful
+ if (responseFromListEvents.success) {
+ await this.trySetCache(responseFromListEvents.data, request, next);
+
+ return {
+ success: true,
+ message: isEmpty(responseFromListEvents.data)
+ ? "no measurements for this search"
+ : responseFromListEvents.message,
+ data: responseFromListEvents.data,
+ status: responseFromListEvents.status || "",
+ isCache: false,
+ };
+ }
+
+ logger.error(
+ `Unable to retrieve events --- ${JSON.stringify(
+ responseFromListEvents.errors
+ )}`
+ );
+ return {
+ success: false,
+ message: responseFromListEvents.message,
+ errors: responseFromListEvents.errors || { message: "" },
+ status: responseFromListEvents.status || "",
+ isCache: false,
+ };
+ } catch (error) {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ }
+
+ async translateHealthTips(response, language, next) {
+ if (
+ language !== undefined &&
+ !isEmpty(response) &&
+ response.success === true &&
+ !isEmpty(response.data)
+ ) {
+ const data = response.data;
+ for (const event of data) {
+ const translatedHealthTips = await translateUtil.translateTips(
+ { healthTips: event.health_tips, targetLanguage: language },
+ next
+ );
+ if (translatedHealthTips.success === true) {
+ event.health_tips = translatedHealthTips.data;
+ }
+ }
+ }
+ }
+
+ async tryGetCache(request, next) {
+ try {
+ return await Promise.race([
+ createEvent.getCache(request, next),
+ this.getCacheTimeout(),
+ ]);
+ } catch (error) {
+ logger.error(`🐛🐛 Cache Get Error -- ${JSON.stringify(error)}`);
+ return { success: false };
+ }
+ }
+
+ async trySetCache(data, request, next) {
+ try {
+ const result = await Promise.race([
+ createEvent.setCache(data, request, next),
+ this.getCacheTimeout(),
+ ]);
+
+ if (!result.success) {
+ logger.error(
+ `🐛🐛 Cache Set Error -- ${JSON.stringify(
+ result.errors || "Unknown error"
+ )}`
+ );
+ }
+ } catch (error) {
+ logger.error(`🐛🐛 Cache Set Error -- ${JSON.stringify(error)}`);
+ }
+ }
+
+ getCacheTimeout() {
+ return new Promise((resolve) =>
+ setTimeout(resolve, 60000, {
+ success: false,
+ message: "Internal Server Error",
+ status: httpStatus.INTERNAL_SERVER_ERROR,
+ errors: { message: "Cache timeout" },
+ })
+ );
+ }
+}
+
const createEvent = {
getMeasurementsFromBigQuery: async (req, next) => {
try {
@@ -807,7 +936,7 @@ const createEvent = {
);
}
},
- listAverages: async (request, next) => {
+ listAveragesV1: async (request, next) => {
try {
let missingDataMessage = "";
const { language, site_id, tenant } = {
@@ -929,6 +1058,16 @@ const createEvent = {
);
}
},
+
+ listAverages: async (request, next) => {
+ const service = new AirQualityService(request.query.tenant);
+ return service.getAirQualityData(request, next);
+ },
+
+ listAveragesV2: async (request, next) => {
+ const service = new AirQualityService(request.query.tenant);
+ return service.getAirQualityData(request, next, "v2");
+ },
view: async (request, next) => {
try {
let missingDataMessage = "";
@@ -2248,6 +2387,7 @@ const createEvent = {
averages,
threshold,
pollutant,
+ quality_checks,
} = { ...request.query, ...request.params };
const currentTime = new Date().toISOString();
const day = generateDateFormatWithoutHrs(currentTime);
@@ -2281,6 +2421,7 @@ const createEvent = {
_${averages ? averages : "noAverages"}
_${threshold ? threshold : "noThreshold"}
_${pollutant ? pollutant : "noPollutant"}
+ _${quality_checks ? quality_checks : "noQualityChecks"}
`;
} catch (error) {
logger.error(`🐛🐛 Internal Server Error ${error.message}`);
diff --git a/src/device-registry/utils/create-forecast.js b/src/device-registry/utils/create-forecast.js
new file mode 100644
index 0000000000..6cebac38fe
--- /dev/null
+++ b/src/device-registry/utils/create-forecast.js
@@ -0,0 +1,202 @@
+const httpStatus = require("http-status");
+const ForecastModel = require("@models/Forecast");
+const constants = require("@config/constants");
+const { logObject } = require("./log");
+const generateFilter = require("./generate-filter");
+const log4js = require("log4js");
+const logger = log4js.getLogger(`${constants.ENVIRONMENT} -- forecast-util`);
+const { HttpError } = require("@utils/errors");
+const { Kafka } = require("kafkajs");
+const isEmpty = require("is-empty");
+
+const kafka = new Kafka({
+ clientId: constants.KAFKA_CLIENT_ID,
+ brokers: constants.KAFKA_BOOTSTRAP_SERVERS,
+});
+
+const processValues = (values, forecast_created_at) => {
+ const processedValues = values.map((value) => ({
+ ...value,
+ forecast_created_at,
+ }));
+
+ // Group values by day and create day-specific records
+ const dayGroups = processedValues.reduce((acc, value) => {
+ const day = value.time.split("T")[0];
+ if (!acc[day]) {
+ acc[day] = [];
+ }
+ acc[day].push(value);
+ return acc;
+ }, {});
+
+ return Object.entries(dayGroups).map(([day, dayValues]) => ({
+ day,
+ values: dayValues,
+ first: dayValues[0].time,
+ last: dayValues[dayValues.length - 1].time,
+ }));
+};
+
+const forecastUtils = {
+ create: async (request, next) => {
+ try {
+ const { body, query } = request;
+ const { tenant } = query;
+ const {
+ device_id,
+ site_id,
+ forecast_created_at,
+ model_version,
+ values,
+ } = body;
+
+ // Process values into day-grouped format
+ const forecastDays = processValues(values, forecast_created_at);
+
+ // Create multiple forecast records, one per day
+ const createPromises = forecastDays.map(async (dayForecast) => {
+ const forecastData = {
+ device_id,
+ site_id,
+ day: dayForecast.day,
+ first: dayForecast.first,
+ last: dayForecast.last,
+ values: dayForecast.values.map((value) => ({
+ ...value,
+ device_id,
+ site_id,
+ model_version,
+ })),
+ };
+
+ return ForecastModel(tenant).register(forecastData, next);
+ });
+
+ const results = await Promise.all(createPromises);
+ const successfulResults = results.filter((result) => result.success);
+
+ if (successfulResults.length > 0) {
+ try {
+ const kafkaProducer = kafka.producer({
+ groupId: constants.UNIQUE_PRODUCER_GROUP,
+ });
+ await kafkaProducer.connect();
+ await kafkaProducer.send({
+ topic: constants.FORECASTS_TOPIC,
+ messages: [
+ {
+ action: "create",
+ value: JSON.stringify(successfulResults.map((r) => r.data)),
+ },
+ ],
+ });
+ await kafkaProducer.disconnect();
+ } catch (error) {
+ logger.error(`internal server error -- ${error.message}`);
+ }
+
+ return {
+ success: true,
+ message: "Successfully created forecasts",
+ data: successfulResults.map((r) => r.data),
+ status: httpStatus.CREATED,
+ };
+ } else {
+ return {
+ success: false,
+ message: "Failed to create forecasts",
+ errors: { message: "No forecasts were created successfully" },
+ status: httpStatus.INTERNAL_SERVER_ERROR,
+ };
+ }
+ } catch (error) {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
+
+ listByDevice: async (request, next) => {
+ try {
+ const { params, query } = request;
+ const { tenant, limit, skip, start_date, end_date } = query;
+ const { deviceId } = params;
+
+ const filter = {
+ device_id: deviceId,
+ };
+
+ if (start_date || end_date) {
+ filter.day = {};
+ if (start_date) filter.day.$gte = start_date.split("T")[0];
+ if (end_date) filter.day.$lte = end_date.split("T")[0];
+ }
+
+ const response = await ForecastModel(tenant).list(
+ {
+ filter,
+ limit,
+ skip,
+ },
+ next
+ );
+
+ return response;
+ } catch (error) {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
+
+ listBySite: async (request, next) => {
+ try {
+ const { params, query } = request;
+ const { tenant, limit, skip, start_date, end_date } = query;
+ const { siteId } = params;
+
+ const filter = {
+ site_id: siteId,
+ };
+
+ if (start_date || end_date) {
+ filter.day = {};
+ if (start_date) filter.day.$gte = start_date.split("T")[0];
+ if (end_date) filter.day.$lte = end_date.split("T")[0];
+ }
+
+ const response = await ForecastModel(tenant).list(
+ {
+ filter,
+ limit,
+ skip,
+ },
+ next
+ );
+
+ return response;
+ } catch (error) {
+ logger.error(`🐛🐛 Internal Server Error ${error.message}`);
+ next(
+ new HttpError(
+ "Internal Server Error",
+ httpStatus.INTERNAL_SERVER_ERROR,
+ { message: error.message }
+ )
+ );
+ }
+ },
+};
+
+module.exports = forecastUtils;
diff --git a/src/device-registry/validators/forecast.validators.js b/src/device-registry/validators/forecast.validators.js
new file mode 100644
index 0000000000..a282d9fa55
--- /dev/null
+++ b/src/device-registry/validators/forecast.validators.js
@@ -0,0 +1,206 @@
+const { check, oneOf, query, body, param } = require("express-validator");
+const constants = require("@config/constants");
+const mongoose = require("mongoose");
+const ObjectId = mongoose.Types.ObjectId;
+const isEmpty = require("is-empty");
+
+const commonValidations = {
+ tenant: [
+ query("tenant")
+ .optional()
+ .notEmpty()
+ .withMessage("the tenant cannot be empty, if provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(constants.NETWORKS)
+ .withMessage("the tenant value is not among the expected ones"),
+ ],
+ deviceId: [
+ param("deviceId")
+ .exists()
+ .withMessage("the device identifier is missing in request")
+ .bail()
+ .trim()
+ .isMongoId()
+ .withMessage("deviceId must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ ],
+ siteId: [
+ param("siteId")
+ .exists()
+ .withMessage("the site identifier is missing in request")
+ .bail()
+ .trim()
+ .isMongoId()
+ .withMessage("siteId must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ ],
+};
+
+const validateForecastValue = {
+ time: [
+ body("values.*.time")
+ .exists()
+ .withMessage("time is required for each forecast value")
+ .bail()
+ .isISO8601()
+ .withMessage("time must be a valid ISO 8601 date"),
+ ],
+ forecast_horizon: [
+ body("values.*.forecast_horizon")
+ .exists()
+ .withMessage("forecast_horizon is required for each forecast value")
+ .bail()
+ .isInt({ min: 0 })
+ .withMessage("forecast_horizon must be a non-negative integer"),
+ ],
+ pm2_5: [
+ body("values.*.pm2_5.value")
+ .optional()
+ .isFloat({ min: 0 })
+ .withMessage("pm2_5 value must be a non-negative number"),
+ body("values.*.pm2_5.confidence_lower")
+ .optional()
+ .isFloat({ min: 0 })
+ .withMessage("pm2_5 confidence_lower must be a non-negative number"),
+ body("values.*.pm2_5.confidence_upper")
+ .optional()
+ .isFloat({ min: 0 })
+ .withMessage("pm2_5 confidence_upper must be a non-negative number")
+ .custom((value, { req }) => {
+ const valueIndex = req.body.values.findIndex(
+ (v) => v.pm2_5.confidence_upper === value
+ );
+ const lower = req.body.values[valueIndex].pm2_5.confidence_lower;
+ if (lower && value <= lower) {
+ throw new Error(
+ "confidence_upper must be greater than confidence_lower"
+ );
+ }
+ return true;
+ }),
+ ],
+ pm10: [
+ body("values.*.pm10.value")
+ .optional()
+ .isFloat({ min: 0 })
+ .withMessage("pm10 value must be a non-negative number"),
+ body("values.*.pm10.confidence_lower")
+ .optional()
+ .isFloat({ min: 0 })
+ .withMessage("pm10 confidence_lower must be a non-negative number"),
+ body("values.*.pm10.confidence_upper")
+ .optional()
+ .isFloat({ min: 0 })
+ .withMessage("pm10 confidence_upper must be a non-negative number")
+ .custom((value, { req }) => {
+ const valueIndex = req.body.values.findIndex(
+ (v) => v.pm10.confidence_upper === value
+ );
+ const lower = req.body.values[valueIndex].pm10.confidence_lower;
+ if (lower && value <= lower) {
+ throw new Error(
+ "confidence_upper must be greater than confidence_lower"
+ );
+ }
+ return true;
+ }),
+ ],
+};
+
+const forecastValidations = {
+ create: [
+ ...commonValidations.tenant,
+ body("device_id")
+ .exists()
+ .withMessage("device_id is required")
+ .bail()
+ .isMongoId()
+ .withMessage("device_id must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ body("site_id")
+ .exists()
+ .withMessage("site_id is required")
+ .bail()
+ .isMongoId()
+ .withMessage("site_id must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ body("forecast_created_at")
+ .exists()
+ .withMessage("forecast_created_at is required")
+ .bail()
+ .isISO8601()
+ .withMessage("forecast_created_at must be a valid ISO 8601 date"),
+ body("model_version")
+ .exists()
+ .withMessage("model_version is required")
+ .bail()
+ .trim()
+ .matches(/^v\d+\.\d+\.\d+$/)
+ .withMessage("model_version must be in format vX.Y.Z"),
+ body("values")
+ .exists()
+ .withMessage("values array is required")
+ .bail()
+ .isArray()
+ .withMessage("values must be an array")
+ .bail()
+ .notEmpty()
+ .withMessage("values array cannot be empty"),
+ ...validateForecastValue.time,
+ ...validateForecastValue.forecast_horizon,
+ ...validateForecastValue.pm2_5,
+ ...validateForecastValue.pm10,
+ ],
+ listByDevice: [
+ ...commonValidations.tenant,
+ ...commonValidations.deviceId,
+ query("start_date")
+ .optional()
+ .isISO8601()
+ .withMessage("start_date must be a valid ISO 8601 date"),
+ query("end_date")
+ .optional()
+ .isISO8601()
+ .withMessage("end_date must be a valid ISO 8601 date")
+ .custom((value, { req }) => {
+ if (req.query.start_date && value <= req.query.start_date) {
+ throw new Error("end_date must be after start_date");
+ }
+ return true;
+ }),
+ ],
+ listBySite: [
+ ...commonValidations.tenant,
+ ...commonValidations.siteId,
+ query("start_date")
+ .optional()
+ .isISO8601()
+ .withMessage("start_date must be a valid ISO 8601 date"),
+ query("end_date")
+ .optional()
+ .isISO8601()
+ .withMessage("end_date must be a valid ISO 8601 date")
+ .custom((value, { req }) => {
+ if (req.query.start_date && value <= req.query.start_date) {
+ throw new Error("end_date must be after start_date");
+ }
+ return true;
+ }),
+ ],
+};
+
+module.exports = forecastValidations;
diff --git a/src/device-registry/validators/tips.validators.js b/src/device-registry/validators/tips.validators.js
new file mode 100644
index 0000000000..af546831f7
--- /dev/null
+++ b/src/device-registry/validators/tips.validators.js
@@ -0,0 +1,162 @@
+const { check, oneOf, query, body } = require("express-validator");
+const constants = require("@config/constants");
+const mongoose = require("mongoose");
+const ObjectId = mongoose.Types.ObjectId;
+const isEmpty = require("is-empty");
+
+const commonValidations = {
+ tenant: [
+ query("tenant")
+ .optional()
+ .notEmpty()
+ .withMessage("the tenant cannot be empty, if provided")
+ .bail()
+ .trim()
+ .toLowerCase()
+ .isIn(constants.NETWORKS)
+ .withMessage("the tenant value is not among the expected ones"),
+ ],
+ id: [
+ query("id")
+ .exists()
+ .withMessage("the tip identifier is missing in request")
+ .bail()
+ .trim()
+ .isMongoId()
+ .withMessage("id must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ ],
+ optionalId: [
+ query("id")
+ .optional()
+ .notEmpty()
+ .withMessage("this tip identifier cannot be empty")
+ .bail()
+ .trim()
+ .isMongoId()
+ .withMessage("id must be an object ID")
+ .bail()
+ .customSanitizer((value) => {
+ return ObjectId(value);
+ }),
+ ],
+ language: [
+ query("language")
+ .optional()
+ .notEmpty()
+ .withMessage("the language cannot be empty when provided")
+ .bail()
+ .trim(),
+ ],
+};
+
+const healthTipValidations = {
+ create: [
+ ...commonValidations.tenant,
+ body("description")
+ .exists()
+ .withMessage("the description is missing in request")
+ .bail()
+ .trim(),
+ body("title")
+ .exists()
+ .withMessage("the title is missing in request")
+ .bail()
+ .trim(),
+ body("image")
+ .exists()
+ .withMessage("the image is missing in request")
+ .bail()
+ .trim(),
+ body("aqi_category")
+ .exists()
+ .withMessage("the aqi_category is missing in request")
+ .bail()
+ .isObject()
+ .withMessage("aqi_category must be an object")
+ .bail(),
+ body("aqi_category.min")
+ .exists()
+ .withMessage("aqi_category.min is required")
+ .bail()
+ .isNumeric()
+ .withMessage("aqi_category.min must be a number"),
+ body("aqi_category.max")
+ .exists()
+ .withMessage("aqi_category.max is required")
+ .bail()
+ .isNumeric()
+ .withMessage("aqi_category.max must be a number")
+ .custom((value, { req }) => {
+ if (value <= req.body.aqi_category.min) {
+ throw new Error("max value must be greater than min value");
+ }
+ return true;
+ }),
+ ],
+ list: [
+ ...commonValidations.tenant,
+ ...commonValidations.optionalId,
+ ...commonValidations.language,
+ ],
+ update: [
+ ...commonValidations.tenant,
+ ...commonValidations.id,
+ body()
+ .notEmpty()
+ .custom((value) => {
+ return !isEmpty(value);
+ })
+ .withMessage("the request body should not be empty"),
+ body("description")
+ .optional()
+ .notEmpty()
+ .withMessage("the description cannot be empty if provided")
+ .bail()
+ .trim(),
+ body("title")
+ .optional()
+ .notEmpty()
+ .withMessage("the title cannot be empty if provided")
+ .bail()
+ .trim(),
+ body("image")
+ .optional()
+ .notEmpty()
+ .withMessage("the image cannot be empty if provided")
+ .bail()
+ .trim(),
+ body("aqi_category")
+ .optional()
+ .notEmpty()
+ .withMessage("the aqi_category cannot be empty if provided")
+ .bail()
+ .isObject()
+ .withMessage("aqi_category must be an object")
+ .bail(),
+ body("aqi_category.min")
+ .optional()
+ .isNumeric()
+ .withMessage("aqi_category.min must be a number"),
+ body("aqi_category.max")
+ .optional()
+ .isNumeric()
+ .withMessage("aqi_category.max must be a number")
+ .custom((value, { req }) => {
+ if (
+ req.body.aqi_category &&
+ req.body.aqi_category.min &&
+ value <= req.body.aqi_category.min
+ ) {
+ throw new Error("max value must be greater than min value");
+ }
+ return true;
+ }),
+ ],
+ delete: [...commonValidations.tenant, ...commonValidations.id],
+};
+
+module.exports = healthTipValidations;
|