define routes

src/controller/admin/unit/equipmentController.ts

@@ -0,0 +1,104 @@
+import { Request, Response } from "express";
+import EquipmentService from "../../../service/unit/equipment/equipmentService";
+import EquipmentFactory from "../../../factory/admin/unit/equipment/equipment";
+import {
+  CreateEquipmentCommand,
+  DeleteEquipmentCommand,
+  UpdateEquipmentCommand,
+} from "../../../command/unit/equipment/equipmentCommand";
+import EquipmentCommandHandler from "../../../command/unit/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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [equipments, total] = await EquipmentService.getAll();
+
+  res.json({
+    equipments: equipments,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @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 salutationId = parseInt(req.body.salutationId);
+
+  let createEquipment: CreateEquipmentCommand = {
+    name: "",
+    location: "",
+    commissioned: undefined,
+    equipmentTypeId: "",
+  };
+  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 salutationId = parseInt(req.body.salutationId);
+
+  let updateEquipment: UpdateEquipmentCommand = {
+    id: equipmentId,
+    name: "",
+    location: "",
+    commissioned: undefined,
+  };
+  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/unit/equipmentTypeController.ts

@@ -0,0 +1,101 @@
+import { Request, Response } from "express";
+import EquipmentTypeService from "../../../service/unit/equipment/equipmentTypeService";
+import EquipmentTypeFactory from "../../../factory/admin/unit/equipment/equipmentType";
+import {
+  CreateEquipmentTypeCommand,
+  DeleteEquipmentTypeCommand,
+  UpdateEquipmentTypeCommand,
+} from "../../../command/unit/equipment/equipmentTypeCommand";
+import EquipmentTypeCommandHandler from "../../../command/unit/equipment/equipmentTypeCommandHandler";
+
+/**
+ * @description get all equipmentTypes
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllEquipmentTypes(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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [equipmentTypes, total] = await EquipmentTypeService.getAll();
+
+  res.json({
+    equipmentTypes: equipmentTypes,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get equipmentType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getEquipmentTypeById(req: Request, res: Response): Promise<any> {
+  const equipmentTypeId = req.params.id;
+  let equipmentType = await EquipmentTypeService.getById(equipmentTypeId);
+
+  res.json(EquipmentTypeFactory.mapToSingle(equipmentType));
+}
+
+/**
+ * @description create equipmentType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createEquipmentType(req: Request, res: Response): Promise<any> {
+  const salutationId = parseInt(req.body.salutationId);
+
+  let createEquipmentType: CreateEquipmentTypeCommand = {
+    type: "",
+    description: "",
+  };
+  let equipmentTypeId = await EquipmentTypeCommandHandler.create(createEquipmentType);
+
+  res.status(200).send(equipmentTypeId);
+}
+
+/**
+ * @description update equipmentType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateEquipmentTypeById(req: Request, res: Response): Promise<any> {
+  const equipmentTypeId = req.params.id;
+  const salutationId = parseInt(req.body.salutationId);
+
+  let updateEquipmentType: UpdateEquipmentTypeCommand = {
+    id: equipmentTypeId,
+    type: "",
+    description: "",
+  };
+  await EquipmentTypeCommandHandler.update(updateEquipmentType);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete equipmentType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteEquipmentTypeById(req: Request, res: Response): Promise<any> {
+  const equipmentTypeId = req.params.id;
+
+  let deleteEquipmentType: DeleteEquipmentTypeCommand = {
+    id: equipmentTypeId,
+  };
+  await EquipmentTypeCommandHandler.delete(deleteEquipmentType);
+
+  res.sendStatus(204);
+}

src/controller/admin/unit/inspectionController.ts

@@ -0,0 +1,106 @@
+import { Request, Response } from "express";
+import InspectionService from "../../../service/unit/inspection/inspectionService";
+import InspectionFactory from "../../../factory/admin/unit/inspection/inspection";
+import {
+  CreateInspectionCommand,
+  DeleteInspectionCommand,
+  UpdateInspectionCommand,
+} from "../../../command/unit/inspection/inspectionCommand";
+import InspectionCommandHandler from "../../../command/unit/inspection/inspectionCommandHandler";
+
+/**
+ * @description get all inspections for related id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllInspectionsForRelated(req: Request, res: Response): Promise<any> {
+  let relation = req.params.related as "vehicle" | "equipment";
+  let relationId = req.params.relatedId as string;
+  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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [inspections, total] = await InspectionService.getAllForRelated({ equipmentId: relationId });
+
+  res.json({
+    inspections: inspections,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get inspection by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getInspectionById(req: Request, res: Response): Promise<any> {
+  const inspectionId = req.params.id;
+  let inspection = await InspectionService.getById(inspectionId);
+
+  res.json(InspectionFactory.mapToSingle(inspection));
+}
+
+/**
+ * @description create inspection
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createInspection(req: Request, res: Response): Promise<any> {
+  const salutationId = parseInt(req.body.salutationId);
+
+  let createInspection: CreateInspectionCommand = {
+    context: "",
+    inspectionPlanId: "",
+    relatedId: "",
+    assigned: "equipment",
+  };
+  let inspectionId = await InspectionCommandHandler.create(createInspection);
+
+  res.status(200).send(inspectionId);
+}
+
+/**
+ * @description update inspection by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateInspectionById(req: Request, res: Response): Promise<any> {
+  const inspectionId = req.params.id;
+  const salutationId = parseInt(req.body.salutationId);
+
+  let updateInspection: UpdateInspectionCommand = {
+    id: inspectionId,
+    context: "",
+  };
+  await InspectionCommandHandler.update(updateInspection);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete inspection by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteInspectionById(req: Request, res: Response): Promise<any> {
+  const inspectionId = req.params.id;
+
+  // TODO finished inspection cannot be deleted
+
+  let deleteInspection: DeleteInspectionCommand = {
+    id: inspectionId,
+  };
+  await InspectionCommandHandler.delete(deleteInspection);
+
+  res.sendStatus(204);
+}

src/controller/admin/unit/inspectionPlanController.ts

@@ -0,0 +1,106 @@
+import { Request, Response } from "express";
+import InspectionPlanService from "../../../service/unit/inspection/inspectionPlanService";
+import InspectionPlanFactory from "../../../factory/admin/unit/inspection/inspectionPlan";
+import {
+  CreateInspectionPlanCommand,
+  DeleteInspectionPlanCommand,
+  UpdateInspectionPlanCommand,
+} from "../../../command/unit/inspection/inspectionPlanCommand";
+import InspectionPlanCommandHandler from "../../../command/unit/inspection/inspectionPlanCommandHandler";
+
+/**
+ * @description get all inspectionPlans
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllInspectionPlansForRelated(req: Request, res: Response): Promise<any> {
+  let relation = req.params.related as "vehicle" | "equipment";
+  let relationId = req.params.relatedId as string;
+  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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [inspectionPlans, total] = await InspectionPlanService.getAllForRelated({ equipmentId: relationId });
+
+  res.json({
+    inspectionPlans: inspectionPlans,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get inspectionPlan by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getInspectionPlanById(req: Request, res: Response): Promise<any> {
+  const inspectionPlanId = req.params.id;
+  let inspectionPlan = await InspectionPlanService.getById(inspectionPlanId);
+
+  res.json(InspectionPlanFactory.mapToSingle(inspectionPlan));
+}
+
+/**
+ * @description create inspectionPlan
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createInspectionPlan(req: Request, res: Response): Promise<any> {
+  const salutationId = parseInt(req.body.salutationId);
+
+  let createInspectionPlan: CreateInspectionPlanCommand = {
+    title: "",
+    inspectionInterval: "1-m",
+    remindTime: "1-m",
+    relatedId: "",
+    assigned: "equipment",
+  };
+  let inspectionPlanId = await InspectionPlanCommandHandler.create(createInspectionPlan);
+
+  res.status(200).send(inspectionPlanId);
+}
+
+/**
+ * @description update inspectionPlan by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateInspectionPlanById(req: Request, res: Response): Promise<any> {
+  const inspectionPlanId = req.params.id;
+  const salutationId = parseInt(req.body.salutationId);
+
+  let updateInspectionPlan: UpdateInspectionPlanCommand = {
+    id: inspectionPlanId,
+    title: "",
+    inspectionInterval: "1-m",
+  };
+  await InspectionPlanCommandHandler.update(updateInspectionPlan);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete inspectionPlan by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteInspectionPlanById(req: Request, res: Response): Promise<any> {
+  const inspectionPlanId = req.params.id;
+
+  let deleteInspectionPlan: DeleteInspectionPlanCommand = {
+    id: inspectionPlanId,
+  };
+  await InspectionPlanCommandHandler.delete(deleteInspectionPlan);
+
+  res.sendStatus(204);
+}

src/controller/admin/unit/vehicleController.ts

@@ -0,0 +1,104 @@
+import { Request, Response } from "express";
+import VehicleService from "../../../service/unit/vehicle/vehicleService";
+import VehicleFactory from "../../../factory/admin/unit/vehicle/vehicle";
+import {
+  CreateVehicleCommand,
+  DeleteVehicleCommand,
+  UpdateVehicleCommand,
+} from "../../../command/unit/vehicle/vehicleCommand";
+import VehicleCommandHandler from "../../../command/unit/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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [vehicles, total] = await VehicleService.getAll();
+
+  res.json({
+    vehicles: vehicles,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @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 salutationId = parseInt(req.body.salutationId);
+
+  let createVehicle: CreateVehicleCommand = {
+    name: "",
+    location: "",
+    commissioned: undefined,
+    vehicleTypeId: "",
+  };
+  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 salutationId = parseInt(req.body.salutationId);
+
+  let updateVehicle: UpdateVehicleCommand = {
+    id: vehicleId,
+    name: "",
+    location: "",
+    commissioned: undefined,
+  };
+  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/controller/admin/unit/vehicleTypeController.ts

@@ -0,0 +1,101 @@
+import { Request, Response } from "express";
+import VehicleTypeService from "../../../service/unit/vehicle/vehicleTypeService";
+import VehicleTypeFactory from "../../../factory/admin/unit/vehicle/vehicleType";
+import {
+  CreateVehicleTypeCommand,
+  DeleteVehicleTypeCommand,
+  UpdateVehicleTypeCommand,
+} from "../../../command/unit/vehicle/vehicleTypeCommand";
+import VehicleTypeCommandHandler from "../../../command/unit/vehicle/vehicleTypeCommandHandler";
+
+/**
+ * @description get all vehicleTypes
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllVehicleTypes(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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [vehicleTypes, total] = await VehicleTypeService.getAll();
+
+  res.json({
+    vehicleTypes: vehicleTypes,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get vehicleType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getVehicleTypeById(req: Request, res: Response): Promise<any> {
+  const vehicleTypeId = req.params.id;
+  let vehicleType = await VehicleTypeService.getById(vehicleTypeId);
+
+  res.json(VehicleTypeFactory.mapToSingle(vehicleType));
+}
+
+/**
+ * @description create vehicleType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createVehicleType(req: Request, res: Response): Promise<any> {
+  const salutationId = parseInt(req.body.salutationId);
+
+  let createVehicleType: CreateVehicleTypeCommand = {
+    type: "",
+    description: "",
+  };
+  let vehicleTypeId = await VehicleTypeCommandHandler.create(createVehicleType);
+
+  res.status(200).send(vehicleTypeId);
+}
+
+/**
+ * @description update vehicleType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateVehicleTypeById(req: Request, res: Response): Promise<any> {
+  const vehicleTypeId = req.params.id;
+  const salutationId = parseInt(req.body.salutationId);
+
+  let updateVehicleType: UpdateVehicleTypeCommand = {
+    id: vehicleTypeId,
+    type: "",
+    description: "",
+  };
+  await VehicleTypeCommandHandler.update(updateVehicleType);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete vehicleType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteVehicleTypeById(req: Request, res: Response): Promise<any> {
+  const vehicleTypeId = req.params.id;
+
+  let deleteVehicleType: DeleteVehicleTypeCommand = {
+    id: vehicleTypeId,
+  };
+  await VehicleTypeCommandHandler.delete(deleteVehicleType);
+
+  res.sendStatus(204);
+}

src/controller/admin/unit/wearableController.ts

@@ -0,0 +1,104 @@
+import { Request, Response } from "express";
+import WearableService from "../../../service/unit/wearable/wearableService";
+import WearableFactory from "../../../factory/admin/unit/wearable/wearable";
+import {
+  CreateWearableCommand,
+  DeleteWearableCommand,
+  UpdateWearableCommand,
+} from "../../../command/unit/wearable/wearableCommand";
+import WearableCommandHandler from "../../../command/unit/wearable/wearableCommandHandler";
+
+/**
+ * @description get all wearables
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllWearables(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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [wearables, total] = await WearableService.getAll();
+
+  res.json({
+    wearables: wearables,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get wearable by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getWearableById(req: Request, res: Response): Promise<any> {
+  const wearableId = req.params.id;
+  let wearable = await WearableService.getById(wearableId);
+
+  res.json(WearableFactory.mapToSingle(wearable));
+}
+
+/**
+ * @description create wearable
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createWearable(req: Request, res: Response): Promise<any> {
+  const salutationId = parseInt(req.body.salutationId);
+
+  let createWearable: CreateWearableCommand = {
+    name: "",
+    location: "",
+    commissioned: undefined,
+    wearableTypeId: "",
+  };
+  let wearableId = await WearableCommandHandler.create(createWearable);
+
+  res.status(200).send(wearableId);
+}
+
+/**
+ * @description update wearable by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateWearableById(req: Request, res: Response): Promise<any> {
+  const wearableId = req.params.id;
+  const salutationId = parseInt(req.body.salutationId);
+
+  let updateWearable: UpdateWearableCommand = {
+    id: wearableId,
+    name: "",
+    location: "",
+    commissioned: undefined,
+  };
+  await WearableCommandHandler.update(updateWearable);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete wearable by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteWearableById(req: Request, res: Response): Promise<any> {
+  const wearableId = req.params.id;
+
+  let deleteWearable: DeleteWearableCommand = {
+    id: wearableId,
+  };
+  await WearableCommandHandler.delete(deleteWearable);
+
+  res.sendStatus(204);
+}

src/controller/admin/unit/wearableTypeController.ts

@@ -0,0 +1,101 @@
+import { Request, Response } from "express";
+import WearableTypeService from "../../../service/unit/wearable/wearableTypeService";
+import WearableTypeFactory from "../../../factory/admin/unit/wearable/wearableType";
+import {
+  CreateWearableTypeCommand,
+  DeleteWearableTypeCommand,
+  UpdateWearableTypeCommand,
+} from "../../../command/unit/wearable/wearableTypeCommand";
+import WearableTypeCommandHandler from "../../../command/unit/wearable/wearableTypeCommandHandler";
+
+/**
+ * @description get all wearableTypes
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getAllWearableTypes(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);
+
+  //{ offset, count, search, noLimit, ids }
+  let [wearableTypes, total] = await WearableTypeService.getAll();
+
+  res.json({
+    wearableTypes: wearableTypes,
+    total: total,
+    offset: offset,
+    count: count,
+  });
+}
+
+/**
+ * @description get wearableType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function getWearableTypeById(req: Request, res: Response): Promise<any> {
+  const wearableTypeId = req.params.id;
+  let wearableType = await WearableTypeService.getById(wearableTypeId);
+
+  res.json(WearableTypeFactory.mapToSingle(wearableType));
+}
+
+/**
+ * @description create wearableType
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function createWearableType(req: Request, res: Response): Promise<any> {
+  const salutationId = parseInt(req.body.salutationId);
+
+  let createWearableType: CreateWearableTypeCommand = {
+    type: "",
+    description: "",
+  };
+  let wearableTypeId = await WearableTypeCommandHandler.create(createWearableType);
+
+  res.status(200).send(wearableTypeId);
+}
+
+/**
+ * @description update wearableType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function updateWearableTypeById(req: Request, res: Response): Promise<any> {
+  const wearableTypeId = req.params.id;
+  const salutationId = parseInt(req.body.salutationId);
+
+  let updateWearableType: UpdateWearableTypeCommand = {
+    id: wearableTypeId,
+    type: "",
+    description: "",
+  };
+  await WearableTypeCommandHandler.update(updateWearableType);
+
+  res.sendStatus(204);
+}
+
+/**
+ * @description delete wearableType by id
+ * @param req {Request} Express req object
+ * @param res {Response} Express res object
+ * @returns {Promise<*>}
+ */
+export async function deleteWearableTypeById(req: Request, res: Response): Promise<any> {
+  const wearableTypeId = req.params.id;
+
+  let deleteWearableType: DeleteWearableTypeCommand = {
+    id: wearableTypeId,
+  };
+  await WearableTypeCommandHandler.delete(deleteWearableType);
+
+  res.sendStatus(204);
+}

src/routes/admin/unit/equipment.ts

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

src/routes/admin/unit/equipmentType.ts

@@ -1,10 +1,45 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../../helpers/permissionHelper";
+import {
+  createEquipmentType,
+  deleteEquipmentTypeById,
+  getAllEquipmentTypes,
+  getEquipmentTypeById,
+  updateEquipmentTypeById,
+} from "../../../controller/admin/unit/equipmentTypeController";
 
 var router = express.Router({ mergeParams: true });
 
 router.get("/", async (req: Request, res: Response) => {
-  res.send("TODO");
+  await getAllEquipmentTypes(req, res);
 });
 
+router.get("/:id", async (req: Request, res: Response) => {
+  await getEquipmentTypeById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "unit", "equipment_type"),
+  async (req: Request, res: Response) => {
+    await createEquipmentType(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "unit", "equipment_type"),
+  async (req: Request, res: Response) => {
+    await updateEquipmentTypeById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "unit", "equipment_type"),
+  async (req: Request, res: Response) => {
+    await deleteEquipmentTypeById(req, res);
+  }
+);
+
 export default router;

src/routes/admin/unit/inspection.ts

@@ -1,10 +1,51 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../../helpers/permissionHelper";
+import {
+  createInspection,
+  deleteInspectionById,
+  getAllInspectionsForRelated,
+  getInspectionById,
+  updateInspectionById,
+} from "../../../controller/admin/unit/inspectionController";
 
 var router = express.Router({ mergeParams: true });
 
-router.get("/", async (req: Request, res: Response) => {
+router.get(["/vehicle/:relatedId", "/equipment/:relatedId"], async (req: Request, res: Response) => {
-  res.send("TODO");
+  if (req.path.startsWith("/vehicle")) {
+    req.params.related = "vehicle";
+  } else {
+    req.params.related = "equipment";
+  }
+
+  await getAllInspectionsForRelated(req, res);
 });
 
+router.get("/:id", async (req: Request, res: Response) => {
+  await getInspectionById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "unit", "inspection"),
+  async (req: Request, res: Response) => {
+    await createInspection(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "unit", "inspection"),
+  async (req: Request, res: Response) => {
+    await updateInspectionById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "unit", "inspection"),
+  async (req: Request, res: Response) => {
+    await deleteInspectionById(req, res);
+  }
+);
+
 export default router;

src/routes/admin/unit/inspectionPlan.ts

@@ -1,10 +1,51 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../../helpers/permissionHelper";
+import {
+  createInspectionPlan,
+  deleteInspectionPlanById,
+  getAllInspectionPlansForRelated,
+  getInspectionPlanById,
+  updateInspectionPlanById,
+} from "../../../controller/admin/unit/inspectionPlanController";
 
 var router = express.Router({ mergeParams: true });
 
-router.get("/", async (req: Request, res: Response) => {
+router.get(["/vehicle/:relatedId", "/equipment/:relatedId"], async (req: Request, res: Response) => {
-  res.send("TODO");
+  if (req.path.startsWith("/vehicle")) {
+    req.params.related = "vehicle";
+  } else {
+    req.params.related = "equipment";
+  }
+
+  await getAllInspectionPlansForRelated(req, res);
 });
 
+router.get("/:id", async (req: Request, res: Response) => {
+  await getInspectionPlanById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "unit", "inspection_plan"),
+  async (req: Request, res: Response) => {
+    await createInspectionPlan(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "unit", "inspection_plan"),
+  async (req: Request, res: Response) => {
+    await updateInspectionPlanById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "unit", "inspection_plan"),
+  async (req: Request, res: Response) => {
+    await deleteInspectionPlanById(req, res);
+  }
+);
+
 export default router;

src/routes/admin/unit/vehicle.ts

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

src/routes/admin/unit/vehicleType.ts

@@ -1,10 +1,45 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../../helpers/permissionHelper";
+import {
+  createVehicleType,
+  deleteVehicleTypeById,
+  getAllVehicleTypes,
+  getVehicleTypeById,
+  updateVehicleTypeById,
+} from "../../../controller/admin/unit/vehicleTypeController";
 
 var router = express.Router({ mergeParams: true });
 
 router.get("/", async (req: Request, res: Response) => {
-  res.send("TODO");
+  await getAllVehicleTypes(req, res);
 });
 
+router.get("/:id", async (req: Request, res: Response) => {
+  await getVehicleTypeById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "unit", "vehicle_type"),
+  async (req: Request, res: Response) => {
+    await createVehicleType(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "unit", "vehicle_type"),
+  async (req: Request, res: Response) => {
+    await updateVehicleTypeById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "unit", "vehicle_type"),
+  async (req: Request, res: Response) => {
+    await deleteVehicleTypeById(req, res);
+  }
+);
+
 export default router;

src/routes/admin/unit/wearable.ts

@@ -1,10 +1,45 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../../helpers/permissionHelper";
+import {
+  createWearable,
+  deleteWearableById,
+  getAllWearables,
+  getWearableById,
+  updateWearableById,
+} from "../../../controller/admin/unit/wearableController";
 
 var router = express.Router({ mergeParams: true });
 
 router.get("/", async (req: Request, res: Response) => {
-  res.send("TODO");
+  await getAllWearables(req, res);
 });
 
+router.get("/:id", async (req: Request, res: Response) => {
+  await getWearableById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "unit", "wearable"),
+  async (req: Request, res: Response) => {
+    await createWearable(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "unit", "wearable"),
+  async (req: Request, res: Response) => {
+    await updateWearableById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "unit", "wearable"),
+  async (req: Request, res: Response) => {
+    await deleteWearableById(req, res);
+  }
+);
+
 export default router;

src/routes/admin/unit/wearableType.ts

@@ -1,10 +1,45 @@
 import express, { Request, Response } from "express";
 import PermissionHelper from "../../../helpers/permissionHelper";
+import {
+  createWearableType,
+  getAllWearableTypes,
+  getWearableTypeById,
+  updateWearableTypeById,
+} from "../../../controller/admin/unit/wearableTypeController";
+import { deleteWearableById } from "../../../controller/admin/unit/wearableController";
 
 var router = express.Router({ mergeParams: true });
 
 router.get("/", async (req: Request, res: Response) => {
-  res.send("TODO");
+  await getAllWearableTypes(req, res);
 });
 
+router.get("/:id", async (req: Request, res: Response) => {
+  await getWearableTypeById(req, res);
+});
+
+router.post(
+  "/",
+  PermissionHelper.passCheckMiddleware("create", "unit", "wearable_type"),
+  async (req: Request, res: Response) => {
+    await createWearableType(req, res);
+  }
+);
+
+router.patch(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("update", "unit", "wearable_type"),
+  async (req: Request, res: Response) => {
+    await updateWearableTypeById(req, res);
+  }
+);
+
+router.delete(
+  "/:id",
+  PermissionHelper.passCheckMiddleware("delete", "unit", "wearable_type"),
+  async (req: Request, res: Response) => {
+    await deleteWearableById(req, res);
+  }
+);
+
 export default router;