Ehrenamt/ff-admin-server
2
0
Fork 0
Code Issues 22 Pull requests Projects Releases 31 Packages Wiki Activity Actions

define routes

Browse source
This commit is contained in:
Julian Krauser 2025-05-31 15:12:16 +02:00
parent 9a1e7e74ca
commit 9f2a08ccc9
16 changed files with 1129 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

104
src/controller/admin/unit/equipmentController.ts
View file

@ -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);
}

101
src/controller/admin/unit/equipmentTypeController.ts
View file

@ -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);
}

106
src/controller/admin/unit/inspectionController.ts
View file

@ -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);
}

106
src/controller/admin/unit/inspectionPlanController.ts
View file

@ -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);
}

104
src/controller/admin/unit/vehicleController.ts
View file

@ -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);
}

101
src/controller/admin/unit/vehicleTypeController.ts
View file

@ -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);
}

104
src/controller/admin/unit/wearableController.ts
View file

@ -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);
}

101
src/controller/admin/unit/wearableTypeController.ts
View file

@ -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);
}

37
src/routes/admin/unit/equipment.ts
View file

@ -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;

37
src/routes/admin/unit/equipmentType.ts
View file

@ -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;

45
src/routes/admin/unit/inspection.ts
View file

@ -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) => {
res.send("TODO");
router.get(["/vehicle/:relatedId", "/equipment/:relatedId"], async (req: Request, res: Response) => {
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;

45
src/routes/admin/unit/inspectionPlan.ts
View file

@ -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) => {
res.send("TODO");
router.get(["/vehicle/:relatedId", "/equipment/:relatedId"], async (req: Request, res: Response) => {
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;

37
src/routes/admin/unit/vehicle.ts
View file

@ -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;

37
src/routes/admin/unit/vehicleType.ts
View file

@ -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;

37
src/routes/admin/unit/wearable.ts
View file

@ -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;

37
src/routes/admin/unit/wearableType.ts
View file

@ -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;