Lf 4765 create get endpoint to fetch list of i ps

packages/api/src/controllers/irrigationPrescriptionController.ts

@@ -0,0 +1,100 @@
+/*
+ *  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 ESciAddon from '../util/ensembleService.js';
+import { fakeIrrigationPrescriptions } from '../../tests/utils/ensembleUtils.js';
+import FarmAddonModel from '../models/farmAddonModel.js';
+import { AddonFunctions, IrrigationPrescription } from '../util/ensembleService.types.js';
+
+interface IrrigationPrescriptionQueryParams {
+  startTime?: string;
+  endTime?: string;
+  shouldSend?: string;
+}
+
+// TODO: LF-4710 - Delete partner_id = 0, remove Partial
+const PARTNER_ID_MAP: Record<string, Partial<AddonFunctions>> = {
+  '0': {},
+  '1': ESciAddon,
+};
+
+const irrigationPrescriptionController = {
+  getPrescriptions() {
+    return async (req: LiteFarmRequest<IrrigationPrescriptionQueryParams>, res: Response) => {
+      try {
+        const { farm_id } = req.headers;
+        const { startTime, endTime, shouldSend } = req.query;
+        const irrigationPrescriptions: IrrigationPrescription[] = [];
+        const partnerErrors: unknown[] = [];
+
+        if (shouldSend === 'true') {
+          // Check for registered farm addons (only esci for now)
+          // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
+          const farmAddonPartnerIds = await FarmAddonModel.getDistinctFarmAddonPartnerIds(farm_id);
+
+          // Return empty array if no addons
+          if (!farmAddonPartnerIds.length) {
+            return res.status(200).send(irrigationPrescriptions);
+          }
+
+          // Loop through addon partners
+          for (const farmAddonPartnerId of farmAddonPartnerIds) {
+            try {
+              const addonPartner = PARTNER_ID_MAP[farmAddonPartnerId.addon_partner_id.toString()];
+              // TODO: LF-4710 - Skip deprecated partner_id = 0 situation
+              // Type guard for undefined functions
+              if (!addonPartner || typeof addonPartner.getIrrigationPrescriptions !== 'function') {
+                continue;
+              }
+
+              irrigationPrescriptions.push(
+                // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
+                ...(await addonPartner.getIrrigationPrescriptions(farm_id, startTime, endTime)),
+              );
+            } catch (error) {
+              partnerErrors.push(error);
+            }
+          }
+
+          // Return an error if there are no prescriptions
+          if (!irrigationPrescriptions.length && partnerErrors.length) {
+            throw partnerErrors.shift();
+          }
+          return res.status(200).send(irrigationPrescriptions);
+        } else {
+          // Return data for dev purposes + QA
+          const mockData = await fakeIrrigationPrescriptions({
+            // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
+            farmId: farm_id,
+            startTime,
+            endTime,
+          });
+          return res.status(200).send(mockData);
+        }
+      } 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/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;