base data CRUD

src/command/configuration/equipment/equipmentCommand.ts

@@ -0,0 +1,20 @@
+export interface CreateEquipmentCommand {
+  code?: string;
+  type?: string;
+  name: string;
+  commissioned?: Date;
+  decommissioned?: Date;
+}
+
+export interface UpdateEquipmentCommand {
+  id: string;
+  code?: string;
+  type?: string;
+  name: string;
+  commissioned?: Date;
+  decommissioned?: Date;
+}
+
+export interface DeleteEquipmentCommand {
+  id: string;
+}

src/command/configuration/equipment/equipmentCommandHandler.ts

@@ -0,0 +1,74 @@
+import { dataSource } from "../../../data-source";
+import { equipment } from "../../../entity/configuration/equipment";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import { CreateEquipmentCommand, DeleteEquipmentCommand, UpdateEquipmentCommand } from "./equipmentCommand";
+
+export default abstract class EquipmentCommandHandler {
+  /**
+   * @description create equipment
+   * @param {CreateEquipmentCommand} createEquipment
+   * @returns {Promise<number>}
+   */
+  static async create(createEquipment: CreateEquipmentCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(equipment)
+      .values({
+        code: createEquipment.code,
+        type: createEquipment.type,
+        name: createEquipment.name,
+        commissioned: createEquipment.commissioned,
+        decommissioned: createEquipment.decommissioned,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "equipment", err);
+      });
+  }
+
+  /**
+   * @description update equipment
+   * @param {UpdateEquipmentCommand} updateEquipment
+   * @returns {Promise<void>}
+   */
+  static async update(updateEquipment: UpdateEquipmentCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(equipment)
+      .set({
+        code: updateEquipment.code,
+        type: updateEquipment.type,
+        name: updateEquipment.name,
+        commissioned: updateEquipment.commissioned,
+        decommissioned: updateEquipment.decommissioned,
+      })
+      .where("id = :id", { id: updateEquipment.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "equipment", err);
+      });
+  }
+
+  /**
+   * @description delete equipment
+   * @param {DeleteEquipmentCommand} deleteEquipment
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteEquipment: DeleteEquipmentCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(equipment)
+      .where("id = :id", { id: deleteEquipment.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "equipment", err);
+      });
+  }
+}

src/command/configuration/force/forceCommand.ts

@@ -0,0 +1,22 @@
+export interface CreateForceCommand {
+  internalId?: string;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  commissioned?: Date;
+  decommissioned?: Date;
+}
+
+export interface UpdateForceCommand {
+  id: string;
+  internalId?: string;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  commissioned?: Date;
+  decommissioned?: Date;
+}
+
+export interface DeleteForceCommand {
+  id: string;
+}

src/command/configuration/force/forceCommandHandler.ts

@@ -0,0 +1,76 @@
+import { dataSource } from "../../../data-source";
+import { force } from "../../../entity/configuration/force";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import { CreateForceCommand, DeleteForceCommand, UpdateForceCommand } from "./forceCommand";
+
+export default abstract class ForceCommandHandler {
+  /**
+   * @description create force
+   * @param {CreateForceCommand} createForce
+   * @returns {Promise<number>}
+   */
+  static async create(createForce: CreateForceCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(force)
+      .values({
+        internalId: createForce.internalId,
+        firstname: createForce.firstname,
+        lastname: createForce.lastname,
+        nameaffix: createForce.nameaffix,
+        commissioned: createForce.commissioned,
+        decommissioned: createForce.decommissioned,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "force", err);
+      });
+  }
+
+  /**
+   * @description update force
+   * @param {UpdateForceCommand} updateForce
+   * @returns {Promise<void>}
+   */
+  static async update(updateForce: UpdateForceCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(force)
+      .set({
+        internalId: updateForce.internalId,
+        firstname: updateForce.firstname,
+        lastname: updateForce.lastname,
+        nameaffix: updateForce.nameaffix,
+        commissioned: updateForce.commissioned,
+        decommissioned: updateForce.decommissioned,
+      })
+      .where("id = :id", { id: updateForce.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "force", err);
+      });
+  }
+
+  /**
+   * @description delete force
+   * @param {DeleteForceCommand} deleteForce
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteForce: DeleteForceCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(force)
+      .where("id = :id", { id: deleteForce.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "force", err);
+      });
+  }
+}

src/command/configuration/member/memberCommand.ts

@@ -1,22 +0,0 @@
-export interface CreateMemberCommand {
-  salutationId: number;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-  birthdate: Date;
-  internalId?: string;
-}
-
-export interface UpdateMemberCommand {
-  id: string;
-  salutationId: number;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-  birthdate: Date;
-  internalId?: string;
-}
-
-export interface DeleteMemberCommand {
-  id: string;
-}

src/command/configuration/member/memberCommandHandler.ts

@@ -1,70 +0,0 @@
-import { dataSource } from "../../../data-source";
-import { member } from "../../../entity/configuration/member";
-import DatabaseActionException from "../../../exceptions/databaseActionException";
-import { CreateMemberCommand, DeleteMemberCommand, UpdateMemberCommand } from "./memberCommand";
-
-export default abstract class MemberCommandHandler {
-  /**
-   * @description create member
-   * @param {CreateMemberCommand} createMember
-   * @returns {Promise<number>}
-   */
-  static async create(createMember: CreateMemberCommand): Promise<number> {
-    return await dataSource
-      .createQueryBuilder()
-      .insert()
-      .into(member)
-      .values({
-        firstname: createMember.firstname,
-        lastname: createMember.lastname,
-        nameaffix: createMember.nameaffix,
-      })
-      .execute()
-      .then((result) => {
-        return result.identifiers[0].id;
-      })
-      .catch((err) => {
-        throw new DatabaseActionException("CREATE", "member", err);
-      });
-  }
-
-  /**
-   * @description update member
-   * @param {UpdateMemberCommand} updateMember
-   * @returns {Promise<void>}
-   */
-  static async update(updateMember: UpdateMemberCommand): Promise<void> {
-    return await dataSource
-      .createQueryBuilder()
-      .update(member)
-      .set({
-        firstname: updateMember.firstname,
-        lastname: updateMember.lastname,
-        nameaffix: updateMember.nameaffix,
-      })
-      .where("id = :id", { id: updateMember.id })
-      .execute()
-      .then(() => {})
-      .catch((err) => {
-        throw new DatabaseActionException("UPDATE", "member", err);
-      });
-  }
-
-  /**
-   * @description delete member
-   * @param {DeleteMemberCommand} deleteMember
-   * @returns {Promise<void>}
-   */
-  static async delete(deleteMember: DeleteMemberCommand): Promise<void> {
-    return await dataSource
-      .createQueryBuilder()
-      .delete()
-      .from(member)
-      .where("id = :id", { id: deleteMember.id })
-      .execute()
-      .then(() => {})
-      .catch((err) => {
-        throw new DatabaseActionException("DELETE", "member", err);
-      });
-  }
-}

src/command/configuration/vehicle/vehicleCommand.ts

@@ -0,0 +1,20 @@
+export interface CreateVehicleCommand {
+  code?: string;
+  type?: string;
+  name: string;
+  commissioned?: Date;
+  decommissioned?: Date;
+}
+
+export interface UpdateVehicleCommand {
+  id: string;
+  code?: string;
+  type?: string;
+  name: string;
+  commissioned?: Date;
+  decommissioned?: Date;
+}
+
+export interface DeleteVehicleCommand {
+  id: string;
+}

src/command/configuration/vehicle/vehicleCommandHandler.ts

@@ -0,0 +1,74 @@
+import { dataSource } from "../../../data-source";
+import { vehicle } from "../../../entity/configuration/vehicle";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import { CreateVehicleCommand, DeleteVehicleCommand, UpdateVehicleCommand } from "./vehicleCommand";
+
+export default abstract class VehicleCommandHandler {
+  /**
+   * @description create vehicle
+   * @param {CreateVehicleCommand} createVehicle
+   * @returns {Promise<number>}
+   */
+  static async create(createVehicle: CreateVehicleCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(vehicle)
+      .values({
+        code: createVehicle.code,
+        type: createVehicle.type,
+        name: createVehicle.name,
+        commissioned: createVehicle.commissioned,
+        decommissioned: createVehicle.decommissioned,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "vehicle", err);
+      });
+  }
+
+  /**
+   * @description update vehicle
+   * @param {UpdateVehicleCommand} updateVehicle
+   * @returns {Promise<void>}
+   */
+  static async update(updateVehicle: UpdateVehicleCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(vehicle)
+      .set({
+        code: updateVehicle.code,
+        type: updateVehicle.type,
+        name: updateVehicle.name,
+        commissioned: updateVehicle.commissioned,
+        decommissioned: updateVehicle.decommissioned,
+      })
+      .where("id = :id", { id: updateVehicle.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "vehicle", err);
+      });
+  }
+
+  /**
+   * @description delete vehicle
+   * @param {DeleteVehicleCommand} deleteVehicle
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteVehicle: DeleteVehicleCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(vehicle)
+      .where("id = :id", { id: deleteVehicle.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "vehicle", err);
+      });
+  }
+}

src/controller/admin/configuration/equipmentController.ts

@@ -0,0 +1,133 @@
+import { Request, Response } from "express";
+import EquipmentService from "../../../service/configuration/equipmentService";
+import EquipmentFactory from "../../../factory/admin/configuration/equipment";
+import {
+  CreateEquipmentCommand,
+  DeleteEquipmentCommand,
+  UpdateEquipmentCommand,
+} from "../../../command/configuration/equipment/equipmentCommand";
+import EquipmentCommandHandler from "../../../command/configuration/equipment/equipmentCommandHandler";
+
+/**
+ * @description get all equipments
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllEquipments(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  let search = (req.query.search as string) ?? "";
+  let noLimit = req.query.noLimit === "true";
+  let ids = ((req.query.ids ?? "") as string).split(",").filter((i) => i);
+
+  let [equipments, total] = await EquipmentService.getAll({ offset, count, search, noLimit, ids });
+
+  res.json({
+    equipments: EquipmentFactory.mapToBase(equipments),
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get equipments by Ids
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getEquipmentsByIds(req: Request, res: Response): Promise<any> {
+  let ids = req.body.ids as Array<string>;
+
+  let [equipments, total] = await EquipmentService.getAll({ noLimit: true, ids });
+
+  res.json({
+    equipments: EquipmentFactory.mapToBase(equipments),
+    total: total,
+    offset: 0,
+    count: total,
+  });
+}
+
+/**
+ * @description get equipment by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getEquipmentById(req: Request, res: Response): Promise<any> {
+  const equipmentId = req.params.id;
+  let equipment = await EquipmentService.getById(equipmentId);
+
+  res.json(EquipmentFactory.mapToSingle(equipment));
+}
+
+/**
+ * @description create equipment
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createEquipment(req: Request, res: Response): Promise<any> {
+  const code = req.body.code || null;
+  const type = req.body.type || null;
+  const name = req.body.name;
+  const commissioned = req.body.commissioned || undefined;
+  const decommissioned = req.body.decommissioned || undefined;
+
+  let createEquipment: CreateEquipmentCommand = {
+    code,
+    type,
+    name,
+    commissioned,
+    decommissioned,
+  };
+  let equipmentId = await EquipmentCommandHandler.create(createEquipment);
+
+  res.status(200).send(equipmentId);
+}
+
+/**
+ * @description update equipment by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateEquipmentById(req: Request, res: Response): Promise<any> {
+  const equipmentId = req.params.id;
+  const code = req.body.code || null;
+  const type = req.body.type || null;
+  const name = req.body.name;
+  const commissioned = req.body.commissioned || undefined;
+  const decommissioned = req.body.decommissioned || undefined;
+
+  let updateEquipment: UpdateEquipmentCommand = {
+    id: equipmentId,
+    code,
+    type,
+    name,
+    commissioned,
+    decommissioned,
+  };
+  await EquipmentCommandHandler.update(updateEquipment);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete equipment by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteEquipmentById(req: Request, res: Response): Promise<any> {
+  const equipmentId = req.params.id;
+
+  let deleteEquipment: DeleteEquipmentCommand = {
+    id: equipmentId,
+  };
+  await EquipmentCommandHandler.delete(deleteEquipment);
+
+  res.sendStatus(204);
+}

src/controller/admin/configuration/forceController.ts

@@ -0,0 +1,137 @@
+import { Request, Response } from "express";
+import ForceService from "../../../service/configuration/forceService";
+import ForceFactory from "../../../factory/admin/configuration/force";
+import {
+  CreateForceCommand,
+  DeleteForceCommand,
+  UpdateForceCommand,
+} from "../../../command/configuration/force/forceCommand";
+import ForceCommandHandler from "../../../command/configuration/force/forceCommandHandler";
+
+/**
+ * @description get all forces
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllForces(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  let search = (req.query.search as string) ?? "";
+  let noLimit = req.query.noLimit === "true";
+  let ids = ((req.query.ids ?? "") as string).split(",").filter((i) => i);
+
+  let [forces, total] = await ForceService.getAll({ offset, count, search, noLimit, ids });
+
+  res.json({
+    forces: ForceFactory.mapToBase(forces),
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get forces by Ids
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getForcesByIds(req: Request, res: Response): Promise<any> {
+  let ids = req.body.ids as Array<string>;
+
+  let [forces, total] = await ForceService.getAll({ noLimit: true, ids });
+
+  res.json({
+    forces: ForceFactory.mapToBase(forces),
+    total: total,
+    offset: 0,
+    count: total,
+  });
+}
+
+/**
+ * @description get force by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getForceById(req: Request, res: Response): Promise<any> {
+  const forceId = req.params.id;
+  let force = await ForceService.getById(forceId);
+
+  res.json(ForceFactory.mapToSingle(force));
+}
+
+/**
+ * @description create force
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createForce(req: Request, res: Response): Promise<any> {
+  const internalId = req.body.internalId || null;
+  const firstname = req.body.firstname;
+  const lastname = req.body.lastname;
+  const nameaffix = req.body.nameaffix;
+  const commissioned = req.body.commissioned || undefined;
+  const decommissioned = req.body.decommissioned || undefined;
+
+  let createForce: CreateForceCommand = {
+    firstname,
+    lastname,
+    nameaffix,
+    internalId,
+    commissioned,
+    decommissioned,
+  };
+  let forceId = await ForceCommandHandler.create(createForce);
+
+  res.status(200).send(forceId);
+}
+
+/**
+ * @description update force by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateForceById(req: Request, res: Response): Promise<any> {
+  const forceId = req.params.id;
+  const internalId = req.body.internalId || null;
+  const firstname = req.body.firstname;
+  const lastname = req.body.lastname;
+  const nameaffix = req.body.nameaffix;
+  const commissioned = req.body.commissioned || undefined;
+  const decommissioned = req.body.decommissioned || undefined;
+
+  let updateForce: UpdateForceCommand = {
+    id: forceId,
+    firstname,
+    lastname,
+    nameaffix,
+    internalId,
+    commissioned,
+    decommissioned,
+  };
+  await ForceCommandHandler.update(updateForce);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete force by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteForceById(req: Request, res: Response): Promise<any> {
+  const forceId = req.params.id;
+
+  let deleteForce: DeleteForceCommand = {
+    id: forceId,
+  };
+  await ForceCommandHandler.delete(deleteForce);
+
+  res.sendStatus(204);
+}

src/controller/admin/configuration/memberController.ts

@@ -1,137 +0,0 @@
-import { Request, Response } from "express";
-import MemberService from "../../../service/configuration/memberService";
-import MemberFactory from "../../../factory/admin/configuration/member";
-import {
-  CreateMemberCommand,
-  DeleteMemberCommand,
-  UpdateMemberCommand,
-} from "../../../command/configuration/member/memberCommand";
-import MemberCommandHandler from "../../../command/configuration/member/memberCommandHandler";
-
-/**
- * @description get all members
- * @param req {Request} Express req object
- * @param res {Response} Express res object
- * @returns {Promise<*>}
- */
-export async function getAllMembers(req: Request, res: Response): Promise<any> {
-  let offset = parseInt((req.query.offset as string) ?? "0");
-  let count = parseInt((req.query.count as string) ?? "25");
-  let search = (req.query.search as string) ?? "";
-  let noLimit = req.query.noLimit === "true";
-  let ids = ((req.query.ids ?? "") as string).split(",").filter((i) => i);
-
-  let [members, total] = await MemberService.getAll({ offset, count, search, noLimit, ids });
-
-  res.json({
-    members: MemberFactory.mapToBase(members),
-    total: total,
-    offset: offset,
-    count: count,
-  });
-}
-
-/**
- * @description get members by Ids
- * @param req {Request} Express req object
- * @param res {Response} Express res object
- * @returns {Promise<*>}
- */
-export async function getMembersByIds(req: Request, res: Response): Promise<any> {
-  let ids = req.body.ids as Array<string>;
-
-  let [members, total] = await MemberService.getAll({ noLimit: true, ids });
-
-  res.json({
-    members: MemberFactory.mapToBase(members),
-    total: total,
-    offset: 0,
-    count: total,
-  });
-}
-
-/**
- * @description get member by id
- * @param req {Request} Express req object
- * @param res {Response} Express res object
- * @returns {Promise<*>}
- */
-export async function getMemberById(req: Request, res: Response): Promise<any> {
-  const memberId = req.params.id;
-  let member = await MemberService.getById(memberId);
-
-  res.json(MemberFactory.mapToSingle(member));
-}
-
-/**
- * @description create member
- * @param req {Request} Express req object
- * @param res {Response} Express res object
- * @returns {Promise<*>}
- */
-export async function createMember(req: Request, res: Response): Promise<any> {
-  const salutationId = parseInt(req.body.salutationId);
-  const firstname = req.body.firstname;
-  const lastname = req.body.lastname;
-  const nameaffix = req.body.nameaffix;
-  const birthdate = req.body.birthdate;
-  const internalId = req.body.internalId || null;
-
-  let createMember: CreateMemberCommand = {
-    salutationId,
-    firstname,
-    lastname,
-    nameaffix,
-    birthdate,
-    internalId,
-  };
-  let memberId = await MemberCommandHandler.create(createMember);
-
-  res.status(200).send(memberId);
-}
-
-/**
- * @description update member by id
- * @param req {Request} Express req object
- * @param res {Response} Express res object
- * @returns {Promise<*>}
- */
-export async function updateMemberById(req: Request, res: Response): Promise<any> {
-  const memberId = req.params.id;
-  const salutationId = parseInt(req.body.salutationId);
-  const firstname = req.body.firstname;
-  const lastname = req.body.lastname;
-  const nameaffix = req.body.nameaffix;
-  const birthdate = req.body.birthdate;
-  const internalId = req.body.internalId || null;
-
-  let updateMember: UpdateMemberCommand = {
-    id: memberId,
-    salutationId,
-    firstname,
-    lastname,
-    nameaffix,
-    birthdate,
-    internalId,
-  };
-  await MemberCommandHandler.update(updateMember);
-
-  res.sendStatus(204);
-}
-
-/**
- * @description delete member by id
- * @param req {Request} Express req object
- * @param res {Response} Express res object
- * @returns {Promise<*>}
- */
-export async function deleteMemberById(req: Request, res: Response): Promise<any> {
-  const memberId = req.params.id;
-
-  let deleteMember: DeleteMemberCommand = {
-    id: memberId,
-  };
-  await MemberCommandHandler.delete(deleteMember);
-
-  res.sendStatus(204);
-}

src/controller/admin/configuration/vehicleController.ts

@@ -0,0 +1,133 @@
+import { Request, Response } from "express";
+import VehicleService from "../../../service/configuration/vehicleService";
+import VehicleFactory from "../../../factory/admin/configuration/vehicle";
+import {
+  CreateVehicleCommand,
+  DeleteVehicleCommand,
+  UpdateVehicleCommand,
+} from "../../../command/configuration/vehicle/vehicleCommand";
+import VehicleCommandHandler from "../../../command/configuration/vehicle/vehicleCommandHandler";
+
+/**
+ * @description get all vehicles
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllVehicles(req: Request, res: Response): Promise<any> {
+  let offset = parseInt((req.query.offset as string) ?? "0");
+  let count = parseInt((req.query.count as string) ?? "25");
+  let search = (req.query.search as string) ?? "";
+  let noLimit = req.query.noLimit === "true";
+  let ids = ((req.query.ids ?? "") as string).split(",").filter((i) => i);
+
+  let [vehicles, total] = await VehicleService.getAll({ offset, count, search, noLimit, ids });
+
+  res.json({
+    vehicles: VehicleFactory.mapToBase(vehicles),
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get vehicles by Ids
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getVehiclesByIds(req: Request, res: Response): Promise<any> {
+  let ids = req.body.ids as Array<string>;
+
+  let [vehicles, total] = await VehicleService.getAll({ noLimit: true, ids });
+
+  res.json({
+    vehicles: VehicleFactory.mapToBase(vehicles),
+    total: total,
+    offset: 0,
+    count: total,
+  });
+}
+
+/**
+ * @description get vehicle by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getVehicleById(req: Request, res: Response): Promise<any> {
+  const vehicleId = req.params.id;
+  let vehicle = await VehicleService.getById(vehicleId);
+
+  res.json(VehicleFactory.mapToSingle(vehicle));
+}
+
+/**
+ * @description create vehicle
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createVehicle(req: Request, res: Response): Promise<any> {
+  const code = req.body.code || null;
+  const type = req.body.type || null;
+  const name = req.body.name;
+  const commissioned = req.body.commissioned || undefined;
+  const decommissioned = req.body.decommissioned || undefined;
+
+  let createVehicle: CreateVehicleCommand = {
+    code,
+    type,
+    name,
+    commissioned,
+    decommissioned,
+  };
+  let vehicleId = await VehicleCommandHandler.create(createVehicle);
+
+  res.status(200).send(vehicleId);
+}
+
+/**
+ * @description update vehicle by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateVehicleById(req: Request, res: Response): Promise<any> {
+  const vehicleId = req.params.id;
+  const code = req.body.code || null;
+  const type = req.body.type || null;
+  const name = req.body.name;
+  const commissioned = req.body.commissioned || undefined;
+  const decommissioned = req.body.decommissioned || undefined;
+
+  let updateVehicle: UpdateVehicleCommand = {
+    id: vehicleId,
+    code,
+    type,
+    name,
+    commissioned,
+    decommissioned,
+  };
+  await VehicleCommandHandler.update(updateVehicle);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete vehicle by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteVehicleById(req: Request, res: Response): Promise<any> {
+  const vehicleId = req.params.id;
+
+  let deleteVehicle: DeleteVehicleCommand = {
+    id: vehicleId,
+  };
+  await VehicleCommandHandler.delete(deleteVehicle);
+
+  res.sendStatus(204);
+}

src/data-source.ts

@@ -9,7 +9,7 @@ import { invite } from "./entity/management/invite";
 import { userPermission } from "./entity/management/user_permission";
 import { role } from "./entity/management/role";
 import { rolePermission } from "./entity/management/role_permission";
-import { member } from "./entity/configuration/member";
+import { force } from "./entity/configuration/force";
 import { reset } from "./entity/reset";
 
 import { CreateSchema1739697068682 } from "./migrations/1739697068682-CreateSchema";
@@ -24,7 +24,7 @@ const dataSource = new DataSource({
   synchronize: false,
   logging: process.env.NODE_ENV ? true : ["schema", "error", "warn", "log", "migration"],
   bigNumberStrings: false,
-  entities: [user, refresh, invite, reset, userPermission, role, rolePermission, member],
+  entities: [user, refresh, invite, reset, userPermission, role, rolePermission, force],
   migrations: [CreateSchema1739697068682],
   migrationsRun: true,
   migrationsTransactionMode: "each",

src/entity/configuration/force.ts

@@ -1,7 +1,7 @@
 import { Column, Entity, PrimaryColumn } from "typeorm";
 
 @Entity()
-export class member {
+export class force {
   @PrimaryColumn({ generated: "uuid" })
   id: string;
 

src/factory/admin/configuration/equipment.ts

@@ -0,0 +1,29 @@
+import { equipment } from "../../../entity/configuration/equipment";
+import { EquipmentViewModel } from "../../../viewmodel/admin/configuration/equipment.models";
+
+export default abstract class EquipmentFactory {
+  /**
+   * @description map record to equipment
+   * @param {equipment} record
+   * @returns {EquipmentViewModel}
+   */
+  public static mapToSingle(record: equipment): EquipmentViewModel {
+    return {
+      id: record.id,
+      code: record.code,
+      type: record.type,
+      name: record.name,
+      commissioned: record.commissioned,
+      decommissioned: record.decommissioned,
+    };
+  }
+
+  /**
+   * @description map records to equipment
+   * @param {Array<equipment>} records
+   * @returns {Array<EquipmentViewModel>}
+   */
+  public static mapToBase(records: Array<equipment>): Array<EquipmentViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}

src/factory/admin/configuration/force.ts

@@ -0,0 +1,30 @@
+import { force } from "../../../entity/configuration/force";
+import { ForceViewModel } from "../../../viewmodel/admin/configuration/force.models";
+
+export default abstract class ForceFactory {
+  /**
+   * @description map record to force
+   * @param {force} record
+   * @returns {ForceViewModel}
+   */
+  public static mapToSingle(record: force): ForceViewModel {
+    return {
+      id: record.id,
+      internalId: record.internalId,
+      firstname: record.firstname,
+      lastname: record.lastname,
+      nameaffix: record.nameaffix,
+      commissioned: record.commissioned,
+      decommissioned: record.decommissioned,
+    };
+  }
+
+  /**
+   * @description map records to force
+   * @param {Array<force>} records
+   * @returns {Array<ForceViewModel>}
+   */
+  public static mapToBase(records: Array<force>): Array<ForceViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}

src/factory/admin/configuration/member.ts

@@ -1,27 +0,0 @@
-import { member } from "../../../entity/configuration/member";
-import { MemberViewModel } from "../../../viewmodel/admin/configuration/member.models";
-
-export default abstract class MemberFactory {
-  /**
-   * @description map record to member
-   * @param {member} record
-   * @returns {MemberViewModel}
-   */
-  public static mapToSingle(record: member): MemberViewModel {
-    return {
-      id: record?.id,
-      firstname: record?.firstname,
-      lastname: record?.lastname,
-      nameaffix: record?.nameaffix,
-    };
-  }
-
-  /**
-   * @description map records to member
-   * @param {Array<member>} records
-   * @returns {Array<MemberViewModel>}
-   */
-  public static mapToBase(records: Array<member>): Array<MemberViewModel> {
-    return records.map((r) => this.mapToSingle(r));
-  }
-}

src/factory/admin/configuration/vehicle.ts

@@ -0,0 +1,29 @@
+import { vehicle } from "../../../entity/configuration/vehicle";
+import { VehicleViewModel } from "../../../viewmodel/admin/configuration/vehicle.models";
+
+export default abstract class VehicleFactory {
+  /**
+   * @description map record to vehicle
+   * @param {vehicle} record
+   * @returns {VehicleViewModel}
+   */
+  public static mapToSingle(record: vehicle): VehicleViewModel {
+    return {
+      id: record.id,
+      code: record.code,
+      type: record.type,
+      name: record.name,
+      commissioned: record.commissioned,
+      decommissioned: record.decommissioned,
+    };
+  }
+
+  /**
+   * @description map records to vehicle
+   * @param {Array<vehicle>} records
+   * @returns {Array<VehicleViewModel>}
+   */
+  public static mapToBase(records: Array<vehicle>): Array<VehicleViewModel> {
+    return records.map((r) => this.mapToSingle(r));
+  }
+}

src/helpers/backupHelper.ts

@@ -7,7 +7,7 @@ import UserService from "../service/management/userService";
 import { BACKUP_COPIES, BACKUP_INTERVAL } from "../env.defaults";
 import DatabaseActionException from "../exceptions/databaseActionException";
 
-export type BackupSection = "member" | "user";
+export type BackupSection = "force" | "user";
 
 export type BackupSectionRefered = {
   [key in BackupSection]?: Array<string>;
@@ -21,12 +21,12 @@ export type BackupFileContentSection = Array<any> | { [key: string]: Array<any>
 export default abstract class BackupHelper {
   // ! Order matters because of foreign keys
   private static readonly backupSection: Array<{ type: BackupSection; orderOnInsert: number; orderOnClear: number }> = [
-    { type: "member", orderOnInsert: 2, orderOnClear: 2 },
+    { type: "force", orderOnInsert: 2, orderOnClear: 2 },
     { type: "user", orderOnInsert: 1, orderOnClear: 1 },
   ];
 
   private static readonly backupSectionRefered: BackupSectionRefered = {
-    member: ["member"],
+    force: ["force"],
     user: ["user", "user_permission", "role", "role_permission", "invite"],
   };
 
@@ -152,8 +152,8 @@ export default abstract class BackupHelper {
     collectIds: boolean
   ): Promise<Array<any> | { [key: string]: any }> {
     switch (section) {
-      case "member":
+      case "force":
-        return await this.getMemberData(collectIds);
+        return await this.getForceData(collectIds);
       case "user":
         return await this.getUser(collectIds);
       default:
@@ -161,11 +161,11 @@ export default abstract class BackupHelper {
     }
   }
 
-  private static async getMemberData(collectIds: boolean): Promise<Array<any>> {
+  private static async getForceData(collectIds: boolean): Promise<Array<any>> {
     return await dataSource
-      .getRepository("member")
+      .getRepository("force")
-      .createQueryBuilder("member")
+      .createQueryBuilder("force")
-      .select([...(collectIds ? ["member.id"] : []), "member.firstname", "member.lastname", "member.nameaffix"])
+      .select([...(collectIds ? ["force.id"] : []), "force.firstname", "force.lastname", "force.nameaffix"])
       .getMany();
   }
   private static async getUser(collectIds: boolean): Promise<{ [key: string]: Array<any> }> {
@@ -205,12 +205,12 @@ export default abstract class BackupHelper {
     data: BackupFileContentSection,
     collectedIds: boolean
   ): Promise<void> {
-    if (section == "member" && Array.isArray(data)) await this.setMemberData(data);
+    if (section == "force" && Array.isArray(data)) await this.setForceData(data);
     if (section == "user" && !Array.isArray(data)) await this.setUser(data);
   }
 
-  private static async setMemberData(data: Array<any>): Promise<void> {
+  private static async setForceData(data: Array<any>): Promise<void> {
-    await this.transactionManager.getRepository("member").save(data);
+    await this.transactionManager.getRepository("force").save(data);
   }
   private static async setUser(data: { [key: string]: Array<any> }): Promise<void> {
     let usedRoles = (data?.["user"] ?? [])

src/migrations/1739697068682-CreateSchema.ts

@@ -9,7 +9,7 @@ import {
   user_roles_table,
   user_table,
 } from "./baseSchemaTables/admin";
-import { equipment_table, member_table, vehicle_table } from "./baseSchemaTables/configuration";
+import { equipment_table, force_table, vehicle_table } from "./baseSchemaTables/configuration";
 
 export class CreateSchema1739697068682 implements MigrationInterface {
   name = "CreateSchema1739697068682";
@@ -24,7 +24,7 @@ export class CreateSchema1739697068682 implements MigrationInterface {
     await queryRunner.createTable(user_permission_table, true, true, true);
     await queryRunner.createTable(refresh_table, true, true, true);
 
-    await queryRunner.createTable(member_table, true, true, true);
+    await queryRunner.createTable(force_table, true, true, true);
     await queryRunner.createTable(equipment_table, true, true, true);
     await queryRunner.createTable(vehicle_table, true, true, true);
   }
@@ -32,7 +32,7 @@ export class CreateSchema1739697068682 implements MigrationInterface {
   public async down(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.dropTable("vehicle", true, true, true);
     await queryRunner.dropTable("equipment", true, true, true);
-    await queryRunner.dropTable("member", true, true, true);
+    await queryRunner.dropTable("force", true, true, true);
 
     await queryRunner.dropTable("refresh", true, true, true);
     await queryRunner.dropTable("user_permission", true, true, true);

src/migrations/baseSchemaTables/configuration.ts

@@ -1,8 +1,8 @@
 import { Table } from "typeorm";
 import { getDefaultByORM, getTypeByORM, isUUIDPrimary } from "../ormHelper";
 
-export const member_table = new Table({
+export const force_table = new Table({
-  name: "member",
+  name: "force",
   columns: [
     { name: "id", ...getTypeByORM("uuid"), ...isUUIDPrimary },
     { name: "internalId", ...getTypeByORM("varchar", true), default: getDefaultByORM("null"), isUnique: true },

src/routes/admin/configuration/equipment.ts

@@ -0,0 +1,50 @@
+import express, { Request, Response } from "express";
+import {
+  createEquipment,
+  deleteEquipmentById,
+  getAllEquipments,
+  getEquipmentById,
+  getEquipmentsByIds,
+  updateEquipmentById,
+} from "../../../controller/admin/configuration/equipmentController";
+import PermissionHelper from "../../../helpers/permissionHelper";
+
+var router = express.Router({ mergeParams: true });
+
+router.get("/", async (req: Request, res: Response) => {
+  await getAllEquipments(req, res);
+});
+
+router.post("/ids", async (req: Request, res: Response) => {
+  await getEquipmentsByIds(req, res);
+});
+
+router.get("/:id", async (req: Request, res: Response) => {
+  await getEquipmentById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "operation", "equipment"),
+  async (req: Request, res: Response) => {
+    await createEquipment(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "operation", "equipment"),
+  async (req: Request, res: Response) => {
+    await updateEquipmentById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "operation", "equipment"),
+  async (req: Request, res: Response) => {
+    await deleteEquipmentById(req, res);
+  }
+);
+
+export default router;

src/routes/admin/configuration/force.ts

@@ -1,33 +1,33 @@
 import express, { Request, Response } from "express";
 import {
-  createMember,
+  createForce,
-  deleteMemberById,
+  deleteForceById,
-  getAllMembers,
+  getAllForces,
-  getMemberById,
+  getForceById,
-  getMembersByIds,
+  getForcesByIds,
-  updateMemberById,
+  updateForceById,
-} from "../../../controller/admin/configuration/memberController";
+} from "../../../controller/admin/configuration/forceController";
 import PermissionHelper from "../../../helpers/permissionHelper";
 
 var router = express.Router({ mergeParams: true });
 
 router.get("/", async (req: Request, res: Response) => {
-  await getAllMembers(req, res);
+  await getAllForces(req, res);
 });
 
 router.post("/ids", async (req: Request, res: Response) => {
-  await getMembersByIds(req, res);
+  await getForcesByIds(req, res);
 });
 
 router.get("/:id", async (req: Request, res: Response) => {
-  await getMemberById(req, res);
+  await getForceById(req, res);
 });
 
 router.post(
   "/",
   PermissionHelper.passCheckMiddleware("create", "operation", "force"),
   async (req: Request, res: Response) => {
-    await createMember(req, res);
+    await createForce(req, res);
   }
 );
 
@@ -35,7 +35,7 @@ router.patch(
   "/:id",
   PermissionHelper.passCheckMiddleware("update", "operation", "force"),
   async (req: Request, res: Response) => {
-    await updateMemberById(req, res);
+    await updateForceById(req, res);
   }
 );
 
@@ -43,7 +43,7 @@ router.delete(
   "/:id",
   PermissionHelper.passCheckMiddleware("delete", "operation", "force"),
   async (req: Request, res: Response) => {
-    await deleteMemberById(req, res);
+    await deleteForceById(req, res);
   }
 );
 

src/routes/admin/configuration/vehicle.ts

@@ -0,0 +1,50 @@
+import express, { Request, Response } from "express";
+import {
+  createVehicle,
+  deleteVehicleById,
+  getAllVehicles,
+  getVehicleById,
+  getVehiclesByIds,
+  updateVehicleById,
+} from "../../../controller/admin/configuration/vehicleController";
+import PermissionHelper from "../../../helpers/permissionHelper";
+
+var router = express.Router({ mergeParams: true });
+
+router.get("/", async (req: Request, res: Response) => {
+  await getAllVehicles(req, res);
+});
+
+router.post("/ids", async (req: Request, res: Response) => {
+  await getVehiclesByIds(req, res);
+});
+
+router.get("/:id", async (req: Request, res: Response) => {
+  await getVehicleById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "operation", "vehicle"),
+  async (req: Request, res: Response) => {
+    await createVehicle(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "operation", "vehicle"),
+  async (req: Request, res: Response) => {
+    await updateVehicleById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "operation", "vehicle"),
+  async (req: Request, res: Response) => {
+    await deleteVehicleById(req, res);
+  }
+);
+
+export default router;

src/routes/admin/index.ts

@@ -1,7 +1,9 @@
 import express from "express";
 import PermissionHelper from "../../helpers/permissionHelper";
 
-import member from "./configuration/member";
+import equipment from "./configuration/equipment";
+import force from "./configuration/force";
+import vehicle from "./configuration/vehicle";
 
 import role from "./management/role";
 import user from "./management/user";
@@ -10,7 +12,9 @@ import backup from "./management/backup";
 
 var router = express.Router({ mergeParams: true });
 
-router.use("/member", PermissionHelper.passCheckMiddleware("read", "configuration", "force"), member);
+router.use("/equipment", PermissionHelper.passCheckMiddleware("read", "configuration", "equipment"), equipment);
+router.use("/force", PermissionHelper.passCheckMiddleware("read", "configuration", "force"), force);
+router.use("/vehicle", PermissionHelper.passCheckMiddleware("read", "configuration", "vehicle"), vehicle);
 
 router.use("/role", PermissionHelper.passCheckMiddleware("read", "management", "role"), role);
 router.use(

src/service/configuration/equipmentService.ts

@@ -0,0 +1,78 @@
+import { dataSource } from "../../data-source";
+import { equipment } from "../../entity/configuration/equipment";
+import DatabaseActionException from "../../exceptions/databaseActionException";
+
+export default abstract class EquipmentService {
+  /**
+   * @description get all equipments
+   * @returns {Promise<[Array<equipment>, number]>}
+   */
+  static async getAll({
+    offset = 0,
+    count = 25,
+    search = "",
+    noLimit = false,
+    ids = [],
+  }: {
+    offset?: number;
+    count?: number;
+    search?: string;
+    noLimit?: boolean;
+    ids?: Array<string>;
+  }): Promise<[Array<equipment>, number]> {
+    let query = dataSource.getRepository(equipment).createQueryBuilder("equipment");
+
+    if (search != "") {
+      search.split(" ").forEach((term, index) => {
+        const searchQuery = `%${term}%`;
+        const dynamic = "searchQuery" + Math.random().toString(36).substring(2);
+        if (index == 0) {
+          query = query.where(`equipment.name LIKE :${dynamic}`, {
+            [dynamic]: searchQuery,
+          });
+        } else {
+          query = query.orWhere(`equipment.name LIKE :${dynamic}`, {
+            [dynamic]: searchQuery,
+          });
+        }
+      });
+    }
+
+    if (ids.length != 0) {
+      query = query.where("equipment.id IN (:...ids)", { ids: ids });
+    }
+
+    if (!noLimit) {
+      query = query.offset(offset).limit(count);
+    }
+
+    return await query
+      .orderBy("equipment.name")
+      .getManyAndCount()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "equipment", err);
+      });
+  }
+
+  /**
+   * @description get equipment by id
+   * @param {string} id
+   * @returns {Promise<equipment>}
+   */
+  static async getById(id: string): Promise<equipment> {
+    return dataSource
+      .getRepository(equipment)
+      .createQueryBuilder("equipment")
+      .where("equipment.id = :id", { id: id })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "equipment", err);
+      });
+  }
+}

src/service/configuration/forceService.ts

@@ -1,11 +1,11 @@
 import { dataSource } from "../../data-source";
-import { member } from "../../entity/configuration/member";
+import { force } from "../../entity/configuration/force";
 import DatabaseActionException from "../../exceptions/databaseActionException";
 
-export default abstract class MemberService {
+export default abstract class ForceService {
   /**
-   * @description get all members
+   * @description get all forces
-   * @returns {Promise<[Array<member>, number]>}
+   * @returns {Promise<[Array<force>, number]>}
    */
   static async getAll({
     offset = 0,
@@ -19,19 +19,19 @@ export default abstract class MemberService {
     search?: string;
     noLimit?: boolean;
     ids?: Array<string>;
-  }): Promise<[Array<member>, number]> {
+  }): Promise<[Array<force>, number]> {
-    let query = dataSource.getRepository(member).createQueryBuilder("member");
+    let query = dataSource.getRepository(force).createQueryBuilder("force");
 
     if (search != "") {
       search.split(" ").forEach((term, index) => {
         const searchQuery = `%${term}%`;
         const dynamic = "searchQuery" + Math.random().toString(36).substring(2);
         if (index == 0) {
-          query = query.where(`member.firstname LIKE :${dynamic} OR member.lastname LIKE :${dynamic}`, {
+          query = query.where(`force.firstname LIKE :${dynamic} OR force.lastname LIKE :${dynamic}`, {
             [dynamic]: searchQuery,
           });
         } else {
-          query = query.orWhere(`member.firstname LIKE :${dynamic} OR member.lastname LIKE :${dynamic}`, {
+          query = query.orWhere(`force.firstname LIKE :${dynamic} OR force.lastname LIKE :${dynamic}`, {
             [dynamic]: searchQuery,
           });
         }
@@ -39,7 +39,7 @@ export default abstract class MemberService {
     }
 
     if (ids.length != 0) {
-      query = query.where("member.id IN (:...ids)", { ids: ids });
+      query = query.where("force.id IN (:...ids)", { ids: ids });
     }
 
     if (!noLimit) {
@@ -47,34 +47,34 @@ export default abstract class MemberService {
     }
 
     return await query
-      .orderBy("member.lastname")
+      .orderBy("force.lastname")
-      .addOrderBy("member.firstname")
+      .addOrderBy("force.firstname")
-      .addOrderBy("member.nameaffix")
+      .addOrderBy("force.nameaffix")
       .getManyAndCount()
       .then((res) => {
         return res;
       })
       .catch((err) => {
-        throw new DatabaseActionException("SELECT", "member", err);
+        throw new DatabaseActionException("SELECT", "force", err);
       });
   }
 
   /**
-   * @description get member by id
+   * @description get force by id
    * @param {string} id
-   * @returns {Promise<member>}
+   * @returns {Promise<force>}
    */
-  static async getById(id: string): Promise<member> {
+  static async getById(id: string): Promise<force> {
     return dataSource
-      .getRepository(member)
+      .getRepository(force)
-      .createQueryBuilder("member")
+      .createQueryBuilder("force")
-      .where("member.id = :id", { id: id })
+      .where("force.id = :id", { id: id })
       .getOneOrFail()
       .then((res) => {
         return res;
       })
       .catch((err) => {
-        throw new DatabaseActionException("SELECT", "member", err);
+        throw new DatabaseActionException("SELECT", "force", err);
       });
   }
 }

src/service/configuration/vehicleService.ts

@@ -0,0 +1,78 @@
+import { dataSource } from "../../data-source";
+import { vehicle } from "../../entity/configuration/vehicle";
+import DatabaseActionException from "../../exceptions/databaseActionException";
+
+export default abstract class VehicleService {
+  /**
+   * @description get all vehicles
+   * @returns {Promise<[Array<vehicle>, number]>}
+   */
+  static async getAll({
+    offset = 0,
+    count = 25,
+    search = "",
+    noLimit = false,
+    ids = [],
+  }: {
+    offset?: number;
+    count?: number;
+    search?: string;
+    noLimit?: boolean;
+    ids?: Array<string>;
+  }): Promise<[Array<vehicle>, number]> {
+    let query = dataSource.getRepository(vehicle).createQueryBuilder("vehicle");
+
+    if (search != "") {
+      search.split(" ").forEach((term, index) => {
+        const searchQuery = `%${term}%`;
+        const dynamic = "searchQuery" + Math.random().toString(36).substring(2);
+        if (index == 0) {
+          query = query.where(`vehicle.name LIKE :${dynamic}`, {
+            [dynamic]: searchQuery,
+          });
+        } else {
+          query = query.orWhere(`vehicle.name LIKE :${dynamic}`, {
+            [dynamic]: searchQuery,
+          });
+        }
+      });
+    }
+
+    if (ids.length != 0) {
+      query = query.where("vehicle.id IN (:...ids)", { ids: ids });
+    }
+
+    if (!noLimit) {
+      query = query.offset(offset).limit(count);
+    }
+
+    return await query
+      .orderBy("vehicle.name")
+      .getManyAndCount()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "vehicle", err);
+      });
+  }
+
+  /**
+   * @description get vehicle by id
+   * @param {string} id
+   * @returns {Promise<vehicle>}
+   */
+  static async getById(id: string): Promise<vehicle> {
+    return dataSource
+      .getRepository(vehicle)
+      .createQueryBuilder("vehicle")
+      .where("vehicle.id = :id", { id: id })
+      .getOneOrFail()
+      .then((res) => {
+        return res;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("SELECT", "vehicle", err);
+      });
+  }
+}

src/type/permissionTypes.ts

@@ -1,6 +1,6 @@
 export type PermissionSection = "operation" | "configuration" | "management";
 
-export type PermissionModule = "mission" | "force" | "user" | "role" | "backup";
+export type PermissionModule = "mission" | "force" | "vehicle" | "equipment" | "user" | "role" | "backup";
 
 export type PermissionType = "read" | "create" | "update" | "delete";
 
@@ -24,10 +24,18 @@ export type SectionsAndModulesObject = {
 };
 
 export const permissionSections: Array<PermissionSection> = ["operation", "configuration", "management"];
-export const permissionModules: Array<PermissionModule> = ["mission", "force", "user", "role", "backup"];
+export const permissionModules: Array<PermissionModule> = [
+  "mission",
+  "force",
+  "vehicle",
+  "equipment",
+  "user",
+  "role",
+  "backup",
+];
 export const permissionTypes: Array<PermissionType> = ["read", "create", "update", "delete"];
 export const sectionsAndModules: SectionsAndModulesObject = {
   operation: ["mission"],
-  configuration: ["force"],
+  configuration: ["force", "vehicle", "equipment"],
   management: ["user", "role", "backup"],
 };

src/viewmodel/admin/configuration/equipment.models.ts

@@ -0,0 +1,8 @@
+export interface EquipmentViewModel {
+  id: string;
+  code?: string;
+  type?: string;
+  name: string;
+  commissioned: Date;
+  decommissioned?: Date;
+}

src/viewmodel/admin/configuration/force.models.ts

@@ -0,0 +1,9 @@
+export interface ForceViewModel {
+  id: string;
+  internalId?: string;
+  firstname: string;
+  lastname: string;
+  nameaffix: string;
+  commissioned: Date;
+  decommissioned?: Date;
+}

src/viewmodel/admin/configuration/member.models.ts

@@ -1,6 +0,0 @@
-export interface MemberViewModel {
-  id: string;
-  firstname: string;
-  lastname: string;
-  nameaffix: string;
-}

src/viewmodel/admin/configuration/vehicle.models.ts

@@ -0,0 +1,8 @@
+export interface VehicleViewModel {
+  id: string;
+  code?: string;
+  type?: string;
+  name: string;
+  commissioned: Date;
+  decommissioned?: Date;
+}