command Handlers and schema update

src/command/unit/vehicle/vehicleCommand.ts

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

src/command/unit/vehicle/vehicleCommandHandler.ts

@@ -0,0 +1,73 @@
+import { dataSource } from "../../../data-source";
+import { vehicle } from "../../../entity/unit/vehicle/vehicle";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import { CreateVehicleCommand, UpdateVehicleCommand, DeleteVehicleCommand } 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,
+        name: createVehicle.name,
+        location: createVehicle.location,
+        commissioned: createVehicle.commissioned,
+        vehicleTypeId: createVehicle.vehicleTypeId,
+      })
+      .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,
+        name: updateVehicle.name,
+        location: updateVehicle.location,
+        commissioned: updateVehicle.commissioned,
+      })
+      .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/command/unit/vehicle/vehicleTypeCommand.ts

@@ -0,0 +1,14 @@
+export interface CreateVehicleTypeCommand {
+  type: string;
+  description: string;
+}
+
+export interface UpdateVehicleTypeCommand {
+  id: string;
+  type: string;
+  description: string;
+}
+
+export interface DeleteVehicleTypeCommand {
+  id: string;
+}

src/command/unit/vehicle/vehicleTypeCommandHandler.ts

@@ -0,0 +1,68 @@
+import { dataSource } from "../../../data-source";
+import { vehicleType } from "../../../entity/unit/vehicle/vehicleType";
+import DatabaseActionException from "../../../exceptions/databaseActionException";
+import { CreateVehicleTypeCommand, UpdateVehicleTypeCommand, DeleteVehicleTypeCommand } from "./vehicleTypeCommand";
+
+export default abstract class VehicleTypeCommandHandler {
+  /**
+   * @description create vehicleType
+   * @param {CreateVehicleTypeCommand} createVehicleType
+   * @returns {Promise<number>}
+   */
+  static async create(createVehicleType: CreateVehicleTypeCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(vehicleType)
+      .values({
+        type: createVehicleType.type,
+        description: createVehicleType.description,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new DatabaseActionException("CREATE", "vehicleType", err);
+      });
+  }
+
+  /**
+   * @description update vehicleType
+   * @param {UpdateVehicleTypeCommand} updateVehicleType
+   * @returns {Promise<void>}
+   */
+  static async update(updateVehicleType: UpdateVehicleTypeCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(vehicleType)
+      .set({
+        type: updateVehicleType.type,
+        description: updateVehicleType.description,
+      })
+      .where("id = :id", { id: updateVehicleType.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("UPDATE", "vehicleType", err);
+      });
+  }
+
+  /**
+   * @description delete vehicleType
+   * @param {DeleteVehicleTypeCommand} deleteVehicleType
+   * @returns {Promise<void>}
+   */
+  static async delete(deleteVehicleType: DeleteVehicleTypeCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(vehicleType)
+      .where("id = :id", { id: deleteVehicleType.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new DatabaseActionException("DELETE", "vehicleType", err);
+      });
+  }
+}