fetch available by mission

src/controller/admin/configuration/equipmentController.ts

@@ -7,6 +7,7 @@ import {
   UpdateEquipmentCommand,
 } from "../../../command/configuration/equipment/equipmentCommand";
 import EquipmentCommandHandler from "../../../command/configuration/equipment/equipmentCommandHandler";
+import MissionService from "../../../service/operation/missionService";
 
 /**
  * @description get all equipments
@@ -63,6 +64,20 @@ export async function getEquipmentById(req: Request, res: Response): Promise<any
   res.json(EquipmentFactory.mapToSingle(equipment));
 }
 
+/**
+ * @description get available equipments by missionId
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAvailabeEquipmentsByMission(req: Request, res: Response): Promise<any> {
+  const missionId = req.params.missionId;
+  let mission = await MissionService.getById(missionId);
+  let equipments = await EquipmentService.getAvailable(mission.mission_start ?? new Date());
+
+  res.json(EquipmentFactory.mapToBase(equipments));
+}
+
 /**
  * @description create equipment
  * @param req {Request} Express req object

src/controller/admin/configuration/forceController.ts

@@ -7,6 +7,7 @@ import {
   UpdateForceCommand,
 } from "../../../command/configuration/force/forceCommand";
 import ForceCommandHandler from "../../../command/configuration/force/forceCommandHandler";
+import MissionService from "../../../service/operation/missionService";
 
 /**
  * @description get all forces
@@ -63,6 +64,20 @@ export async function getForceById(req: Request, res: Response): Promise<any> {
   res.json(ForceFactory.mapToSingle(force));
 }
 
+/**
+ * @description get available forces by missionId
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAvailabeForcesByMission(req: Request, res: Response): Promise<any> {
+  const missionId = req.params.missionId;
+  let mission = await MissionService.getById(missionId);
+  let forces = await ForceService.getAvailable(mission.mission_start ?? new Date());
+
+  res.json(ForceFactory.mapToBase(forces));
+}
+
 /**
  * @description create force
  * @param req {Request} Express req object

src/controller/admin/configuration/vehicleController.ts

@@ -7,6 +7,7 @@ import {
   UpdateVehicleCommand,
 } from "../../../command/configuration/vehicle/vehicleCommand";
 import VehicleCommandHandler from "../../../command/configuration/vehicle/vehicleCommandHandler";
+import MissionService from "../../../service/operation/missionService";
 
 /**
  * @description get all vehicles
@@ -63,6 +64,20 @@ export async function getVehicleById(req: Request, res: Response): Promise<any>
   res.json(VehicleFactory.mapToSingle(vehicle));
 }
 
+/**
+ * @description get available vehicles by missionId
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAvailabeVehiclesByMission(req: Request, res: Response): Promise<any> {
+  const missionId = req.params.missionId;
+  let mission = await MissionService.getById(missionId);
+  let vehicles = await VehicleService.getAvailable(mission.mission_start ?? new Date());
+
+  res.json(VehicleFactory.mapToBase(vehicles));
+}
+
 /**
  * @description create vehicle
  * @param req {Request} Express req object

src/routes/admin/configuration/equipment.ts

@@ -4,6 +4,7 @@ import {
   decommissionEquipmentById,
   deleteEquipmentById,
   getAllEquipments,
+  getAvailabeEquipmentsByMission,
   getEquipmentById,
   getEquipmentsByIds,
   updateEquipmentById,
@@ -24,6 +25,10 @@ router.get("/:id", async (req: Request, res: Response) => {
   await getEquipmentById(req, res);
 });
 
+router.get("/available/:missionId", async (req: Request, res: Response) => {
+  await getAvailabeEquipmentsByMission(req, res);
+});
+
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "operation", "equipment"),

src/routes/admin/configuration/force.ts

@@ -6,6 +6,7 @@ import {
   getAllForces,
   getForceById,
   getForcesByIds,
+  getAvailabeForcesByMission,
   updateForceById,
 } from "../../../controller/admin/configuration/forceController";
 import PermissionHelper from "../../../helpers/permissionHelper";
@@ -24,6 +25,10 @@ router.get("/:id", async (req: Request, res: Response) => {
   await getForceById(req, res);
 });
 
+router.get("/available/:missionId", async (req: Request, res: Response) => {
+  await getAvailabeForcesByMission(req, res);
+});
+
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "operation", "force"),

src/routes/admin/configuration/vehicle.ts

@@ -4,6 +4,7 @@ import {
   decommissionVehicleById,
   deleteVehicleById,
   getAllVehicles,
+  getAvailabeVehiclesByMission,
   getVehicleById,
   getVehiclesByIds,
   updateVehicleById,
@@ -24,6 +25,10 @@ router.get("/:id", async (req: Request, res: Response) => {
   await getVehicleById(req, res);
 });
 
+router.get("/available/:missionId", async (req: Request, res: Response) => {
+  await getAvailabeVehiclesByMission(req, res);
+});
+
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "operation", "vehicle"),

src/routes/admin/index.ts

@@ -16,9 +16,30 @@ var router = express.Router({ mergeParams: true });
 
 router.use("/mission", PermissionHelper.passCheckMiddleware("read", "operation", "mission"), mission);
 
-router.use("/equipment", PermissionHelper.passCheckMiddleware("read", "configuration", "equipment"), equipment);
+router.use(
-router.use("/force", PermissionHelper.passCheckMiddleware("read", "configuration", "force"), force);
+  "/equipment",
-router.use("/vehicle", PermissionHelper.passCheckMiddleware("read", "configuration", "vehicle"), vehicle);
+  PermissionHelper.passCheckSomeMiddleware([
+    { requiredPermissions: "read", section: "configuration", module: "equipment" },
+    { requiredPermissions: "read", section: "operation", module: "mission" },
+  ]),
+  equipment
+);
+router.use(
+  "/force",
+  PermissionHelper.passCheckSomeMiddleware([
+    { requiredPermissions: "read", section: "configuration", module: "force" },
+    { requiredPermissions: "read", section: "operation", module: "mission" },
+  ]),
+  force
+);
+router.use(
+  "/vehicle",
+  PermissionHelper.passCheckSomeMiddleware([
+    { requiredPermissions: "read", section: "configuration", module: "vehicle" },
+    { requiredPermissions: "read", section: "operation", module: "mission" },
+  ]),
+  vehicle
+);
 
 router.use("/role", PermissionHelper.passCheckMiddleware("read", "management", "role"), role);
 router.use(

src/service/configuration/equipmentService.ts

@@ -1,3 +1,4 @@
+import { Brackets } from "typeorm";
 import { dataSource } from "../../data-source";
 import { equipment } from "../../entity/configuration/equipment";
 import DatabaseActionException from "../../exceptions/databaseActionException";
@@ -75,4 +76,30 @@ export default abstract class EquipmentService {
         throw new DatabaseActionException("SELECT", "equipment", err);
       });
   }
+
+  /**
+   * @description get available equipments
+   * @returns {Promise<Array<equipment>>}
+   */
+  static async getAvailable(keyDate: Date): Promise<Array<equipment>> {
+    return await dataSource
+      .getRepository(equipment)
+      .createQueryBuilder("equipment")
+      .where("equipment.commissioned <= :keyDate_start", { keyDate_start: keyDate })
+      .andWhere(
+        new Brackets((qb) =>
+          qb
+            .where("equipment.decommissioned IS NULL")
+            .orWhere("equipment.decommissioned >= :keyDate_end", { keyDate_end: keyDate })
+        )
+      )
+      .orderBy("equipment.name")
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "equipment", err);
+      });
+  }
 }

src/service/configuration/forceService.ts

@@ -1,3 +1,4 @@
+import { Brackets } from "typeorm";
 import { dataSource } from "../../data-source";
 import { force } from "../../entity/configuration/force";
 import DatabaseActionException from "../../exceptions/databaseActionException";
@@ -77,4 +78,32 @@ export default abstract class ForceService {
         throw new DatabaseActionException("SELECT", "force", err);
       });
   }
+
+  /**
+   * @description get available forces
+   * @returns {Promise<Array<force>>}
+   */
+  static async getAvailable(keyDate: Date): Promise<Array<force>> {
+    return await dataSource
+      .getRepository(force)
+      .createQueryBuilder("force")
+      .where("force.commissioned <= :keyDate_start", { keyDate_start: keyDate })
+      .andWhere(
+        new Brackets((qb) =>
+          qb
+            .where("force.decommissioned IS NULL")
+            .orWhere("force.decommissioned >= :keyDate_end", { keyDate_end: keyDate })
+        )
+      )
+      .orderBy("force.lastname")
+      .addOrderBy("force.firstname")
+      .addOrderBy("force.nameaffix")
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "force", err);
+      });
+  }
 }

src/service/configuration/vehicleService.ts

@@ -1,3 +1,4 @@
+import { Brackets } from "typeorm";
 import { dataSource } from "../../data-source";
 import { vehicle } from "../../entity/configuration/vehicle";
 import DatabaseActionException from "../../exceptions/databaseActionException";
@@ -75,4 +76,30 @@ export default abstract class VehicleService {
         throw new DatabaseActionException("SELECT", "vehicle", err);
       });
   }
+
+  /**
+   * @description get available vehicles
+   * @returns {Promise<Array<vehicle>>}
+   */
+  static async getAvailable(keyDate: Date): Promise<Array<vehicle>> {
+    return await dataSource
+      .getRepository(vehicle)
+      .createQueryBuilder("vehicle")
+      .where("vehicle.commissioned <= :keyDate_start", { keyDate_start: keyDate })
+      .andWhere(
+        new Brackets((qb) =>
+          qb
+            .where("vehicle.decommissioned IS NULL")
+            .orWhere("vehicle.decommissioned >= :keyDate_end", { keyDate_end: keyDate })
+        )
+      )
+      .orderBy("vehicle.name")
+      .getMany()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "vehicle", err);
+      });
+  }
 }