Lf 4765 create get endpoint to fetch list of i ps

packages/api/src/controllers/irrigationPrescriptionController.ts

@@ -0,0 +1,52 @@
+/*
+ *  Copyright 2025 LiteFarm.org
+ *  This file is part of LiteFarm.
+ *
+ *  LiteFarm is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  LiteFarm is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details, see <https://www.gnu.org/licenses/>.
+ */
+
+import { Response } from 'express';
+import { LiteFarmRequest, HttpError } from '../types.js';
+import { IrrigationPrescriptionQueryParams } from '../middleware/validation/checkIrrigationPrescription.js';
+import { getAddonPartnerIrrigationPrescriptions } from '../services/addonPartner.js';
+
+const irrigationPrescriptionController = {
+  getPrescriptions() {
+    return async (
+      req: LiteFarmRequest<Required<IrrigationPrescriptionQueryParams>>,
+      res: Response,
+    ) => {
+      try {
+        const { farm_id } = req.headers;
+        const { startTime, endTime, shouldSend } = req.query;
+
+        const irrigationPrescriptions = await getAddonPartnerIrrigationPrescriptions(
+          // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
+          farm_id,
+          startTime,
+          endTime,
+          shouldSend,
+        );
+
+        return res.status(200).send(irrigationPrescriptions);
+      } catch (error: unknown) {
+        console.error(error);
+        const err = error as HttpError;
+        const status = err.status || err.code || 500;
+        return res.status(status).json({
+          error: err.message || err,
+        });
+      }
+    };
+  },
+};
+
+export default irrigationPrescriptionController;

packages/api/src/controllers/irrigationPrescriptionRequestController.ts

@@ -13,28 +13,26 @@
  *  GNU General Public License for more details, see <https://www.gnu.org/licenses/>.
  */
 
-import { Request, Response } from 'express';
+import { Response } from 'express';
 import { getOrgLocationAndCropData, sendFieldAndCropDataToEsci } from '../util/ensembleService.js';
+import { LiteFarmRequest } from '../types.js';
 
 interface HttpError extends Error {
   status?: number;
   code?: number; // LF custom error
 }
 
-interface LiteFarmQuery {
+interface InitiateFarmIrrigationPrescriptionQueryParams {
   allOrgs?: string;
   shouldSend?: string;
 }
 
-export interface LiteFarmRequest extends Request<unknown, unknown, unknown, LiteFarmQuery> {
-  headers: Request['headers'] & {
-    farm_id?: string;
-  };
-}
-
 const irrigationPrescriptionRequestController = {
   initiateFarmIrrigationPrescription() {
-    return async (req: LiteFarmRequest, res: Response) => {
+    return async (
+      req: LiteFarmRequest<InitiateFarmIrrigationPrescriptionQueryParams>,
+      res: Response,
+    ) => {
       const { farm_id } = req.headers;
       const { allOrgs, shouldSend } = req.query;
 

packages/api/src/middleware/validation/checkIrrigationPrescription.ts

@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2025 LiteFarm.org
+ *  This file is part of LiteFarm.
+ *
+ *  LiteFarm is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  LiteFarm is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *  GNU General Public License for more details, see <https://www.gnu.org/licenses/>.
+ */
+
+import { Request, Response, NextFunction } from 'express';
+import { isISO8601Format } from '../../util/validation.js';
+
+export interface IrrigationPrescriptionQueryParams {
+  startTime?: string;
+  endTime?: string;
+  shouldSend?: string;
+}
+
+export function checkGetIrrigationPrescription() {
+  return async (
+    req: Request<unknown, unknown, unknown, IrrigationPrescriptionQueryParams>,
+    res: Response,
+    next: NextFunction,
+  ) => {
+    const { startTime, endTime, shouldSend } = req.query;
+
+    if (shouldSend != 'true' && shouldSend != 'false') {
+      return res.status(400).send('Please provide shouldSend as true or false');
+    }
+
+    if (!startTime || !isISO8601Format(startTime)) {
+      return res.status(400).send('Please provide startTime in ISO 8601 format');
+    }
+
+    if (!endTime || !isISO8601Format(endTime)) {
+      return res.status(400).send('Please provide endTime in ISO 8601 format');
+    }
+
+    next();
+  };
+}

packages/api/src/models/farmAddonModel.js

@@ -121,6 +121,19 @@ class FarmAddon extends baseModel {
       .where('addon_partner_id', addonPartnerId)
       .whereNotDeleted();
   }
+
+  /**
+   * Retrieves unique addon partner ids from farm addons.
+   *
+   * @param {string} farmId - The ID of the farm.
+   * @returns {Promise<Array<{addon_partner_id: number}>>} The partner identifiers for the farm queried.
+   */
+  static async getDistinctFarmAddonPartnerIds(farmId) {
+    return FarmAddon.query()
+      .distinct('addon_partner_id')
+      .where('farm_id', farmId)
+      .whereNotDeleted();
+  }
 }
 
 export default FarmAddon;

packages/api/src/models/irrigationTypesModel.js

@@ -17,7 +17,7 @@ class IrrigationTypesModel extends BaseModel {
       type: 'object',
       required: [''],
       properties: {
-        irrigation_type_id: { type: 'string' },
+        irrigation_type_id: { type: 'integer' },
         irrigation_type_name: { type: 'string' },
         farm_id: { type: 'string' },
         default_measuring_type: { type: 'string' },

packages/api/src/models/taskModel.js

@@ -360,16 +360,19 @@ class TaskModel extends BaseModel {
    */
   static async getUnassignedTasksDueThisWeekFromIds(taskIds, isDayLaterThanUTC = false) {
     const dayLaterInterval = isDayLaterThanUTC ? '"1 day"' : '"0 days"';
-    return await TaskModel.query().select('*').whereIn('task_id', taskIds).whereRaw(
-      `
+    return await TaskModel.query()
+      .select('*')
+      .whereIn('task_id', taskIds)
+      .whereRaw(
+        `
       task.assignee_user_id IS NULL
       AND task.complete_date IS NULL
       AND task.abandon_date IS NULL
       AND task.due_date <= (now() + ('1 week')::interval + (?)::interval)::date
       AND task.due_date >= (now() + (?)::interval)::date
       `,
-      [dayLaterInterval, dayLaterInterval],
-    );
+        [dayLaterInterval, dayLaterInterval],
+      );
   }
 
   /**
@@ -510,6 +513,25 @@ class TaskModel extends BaseModel {
       .withGraphFetched('[animals(selectId), animal_batches(selectId)]')
       .whereIn('task_id', taskIds);
   }
+
+  /**
+   * Returns farm tasks for an array of external ids
+   *
+   * @param {string} farmId - The farm requesting irrigation tasks.
+   * @param {number[]} externalIds - Array of external irrigation prescription ids of interest.
+   * @static
+   * @async
+   * @returns {import('./types.js').IrrigationTask[]} - Returns found irrigation tasks.
+   */
+  static async getIrrigationTasksWithExternalIdByFarm(farmId, externalIds) {
+    return await TaskModel.query()
+      .select('task.*')
+      .withGraphJoined('[locations, irrigation_task]')
+      .whereNotNull('irrigation_task.irrigation_prescription_external_id')
+      .whereIn('irrigation_task.irrigation_prescription_external_id', externalIds)
+      .where('locations.farm_id', farmId)
+      .whereNotDeleted();
+  }
 }
 
 export default TaskModel;