add Coach Sequence feature

.env.example

@@ -0,0 +1,14 @@
+# Specify the backend URL which is used in the frontend. You can not adjust this to the backend container_name as it is not reachable from the frontend!
+# Do not add a "/" at the end, as the frontend will add the path to the API endpoint itself.
+VITE_BACKEND_BASE_URL=http://localhost:8000
+
+# Specify the backend URL which is used in the frontend for SvelteKit SSR. Running in a docker container, you should use the container_name of the backend service.
+# Do not add a "/" at the end, as the frontend will add the path to the API endpoint itself.
+VITE_BACKEND_DOCKER_BASE_URL=http://navigator-backend:8000
+
+# Redis configuration
+REDIS_HOST=navigator-redis
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_USER=navigator-stations
+REDIS_PASSWORD=password

.github/workflows/linting.yml

@@ -1,8 +1,6 @@
 name: Linting Checks
 
 on:
-  push:
-    branches: ["*"]
   pull_request:
     branches: ["*"]
   workflow_dispatch:

backend/Dockerfile

@@ -1,21 +1,18 @@
-# Use the official Bun image as the base image
 FROM oven/bun:latest
-
-# Set the working directory inside the container
 WORKDIR /app
 
-# Copy dependency files first to leverage Docker layer caching
 COPY package.json bun.lockb* ./
 
-# Install dependencies
 RUN bun install
-
-# Copy the rest of your application code (all files and folders)
 COPY . .
+
+ENV REDIS_HOST=navigator-redis
+ENV REDIS_PORT=6379
+ENV REDIS_DB=0
+ENV REDIS_USER=navigator-stations
+ENV REDIS_PASSWORD=password
+
 RUN bun tsoa
 
-# Expose port 8000 (the port your app listens on)
 EXPOSE 8000
-
-# Start the application (adjust the entry point file if necessary)
 CMD ["bun", "run", "server.ts"]

backend/controllers/StationsController.ts

@@ -1,9 +1,10 @@
 import { type Station } from "../models/station.ts";
 import { mapToEnum, Products } from "../models/products.ts";
-import { Controller, Get, Path, Query, Res, Route, type TsoaResponse } from "tsoa";
+import { Controller, Get, Path, Query, Res, Route, Tags, type TsoaResponse } from "tsoa";
 import { getRedisClient } from "../lib/redis.ts";
 
 @Route("stations")
+@Tags("Stations")
 export class StationController extends Controller {
 	@Get()
 	async queryStations(
@@ -19,11 +20,11 @@ export class StationController extends Controller {
 
 	@Get("/{evaNumber}")
 	async getStationByEvaNumber(
-		@Path() evaNumber: number,
+		@Path() evaNumber: string,
 		@Res() badRequestResponse: TsoaResponse<400, { reason: string }>
 	): Promise<Station> {
-		if (!Number.isInteger(evaNumber)) {
-			return badRequestResponse(400, { reason: "EvaNumber is not an integer" });
+		if (!/^\d+$/.test(evaNumber)) {
+			return badRequestResponse(400, { reason: "evaNumber is not an integer" });
 		}
 
 		const cachedStation = await getCachedStation(evaNumber.toString());
@@ -52,12 +53,12 @@ const fetchStation = async (searchTerm: string): Promise<Station[]> => {
 	});
 
 	if (!request.ok) {
-		throw new Error("HTTP Request error occurred");
+		throw new Error(`Failed to fetch stations for ${searchTerm}`);
 	}
 
 	const response = await request.json();
 	if (!response || !Array.isArray(response)) {
-		throw new Error("Invalid response format");
+		throw new Error(`Response was expected to be an array, but got ${typeof response}`);
 	}
 
 	return response.map((data: any) => ({

backend/controllers/journey/SequenceController.ts

@@ -0,0 +1,50 @@
+import { Controller, Get, Queries, Res, Route, Tags, type TsoaResponse } from "tsoa";
+import { DateTime } from "luxon";
+import { mapCoachSequence } from "../../lib/mapping.ts";
+
+class SequenceQuery {
+	lineDetails!: string;
+	evaNumber!: string;
+	date!: string;
+}
+
+@Route("journey/sequence")
+@Tags("Coach Sequences")
+export class SequenceController extends Controller {
+	@Get()
+	async getSequenceById(
+		@Queries() query: SequenceQuery,
+		@Res() badRequestResponse: TsoaResponse<400, { reason: string }>
+	): Promise<any> {
+		if (query.lineDetails === "") {
+			return badRequestResponse(400, { reason: "lineDetails must not be empty" });
+		}
+		if (!/^\d+$/.test(query.evaNumber)) {
+			return badRequestResponse(400, { reason: "evaNumber is not an integer" });
+		}
+
+		const dateValidation = DateTime.fromFormat(query.date, "yyyyMMdd");
+		if (!dateValidation.isValid) {
+			return badRequestResponse(400, { reason: `${dateValidation.invalidExplanation}` });
+		}
+
+		return fetchCoachSequence(query);
+	}
+}
+
+const fetchCoachSequence = async (query: SequenceQuery): Promise<any> => {
+	const request = await fetch(`https://app.vendo.noncd.db.de/mob/zuglaeufe/${query.lineDetails}/halte/by-abfahrt/${query.evaNumber}_${query.date}/wagenreihung`, {
+		method: "GET",
+		headers: {
+			Accept: "application/x.db.vendo.mob.wagenreihung.v3+json",
+			"Content-Type": "application/x.db.vendo.mob.wagenreihung.v3+json",
+			"X-Correlation-ID": crypto.randomUUID() + "_" + crypto.randomUUID()
+		}
+	});
+
+	if (!request.ok) {
+		throw new Error("Failed to fetch coach sequence");
+	}
+
+	return mapCoachSequence(await request.json());
+};

backend/controllers/timetable/BahnhofController.ts

@@ -1,5 +1,5 @@
 import { type RequestType, retrieveBahnhofJourneys } from "./requests.ts";
-import { Controller, Get, Queries, Route } from "tsoa";
+import { Controller, Get, Queries, Route, Tags } from "tsoa";
 import type { Journey } from "../../models/connection.ts";
 
 class BahnhofQuery {
@@ -10,6 +10,7 @@ class BahnhofQuery {
 }
 
 @Route("timetable/bahnhof")
+@Tags("Bahnhof")
 export class BahnhofController extends Controller {
 	@Get()
 	async getBahnhofJourneys(@Queries() query: BahnhofQuery): Promise<Journey[]> {

backend/controllers/timetable/CombinedController.ts

@@ -3,7 +3,7 @@ import { RequestType, retrieveBahnhofJourneys, retrieveCombinedConnections } fro
 import type { Connection, Journey } from "../../models/connection.ts";
 import { isMatching } from "../../lib/merge.ts";
 import calculateDuration from "../../lib/time.ts";
-import { Controller, Get, Queries, Res, Route, type TsoaResponse } from "tsoa";
+import { Controller, Get, Queries, Res, Route, Tags, type TsoaResponse } from "tsoa";
 
 class CombinedQuery {
 	evaNumber!: string;
@@ -15,6 +15,7 @@ class CombinedQuery {
 }
 
 @Route("timetable/combined")
+@Tags("Combined")
 export class CombinedController extends Controller {
 	@Get()
 	async getCombinedJourneys(

backend/controllers/timetable/VendoController.ts

@@ -1,6 +1,6 @@
 import { DateTime } from "luxon";
 import { Profile, RequestType, retrieveCombinedConnections, retrieveConnections } from "./requests.ts";
-import { Controller, Get, Queries, Res, Route, type TsoaResponse } from "tsoa";
+import { Controller, Get, Queries, Res, Route, Tags, type TsoaResponse } from "tsoa";
 import type { Journey } from "../../models/connection.ts";
 
 class VendoQuery {
@@ -13,6 +13,7 @@ class VendoQuery {
 }
 
 @Route("timetable/vendo")
+@Tags("Vendo")
 export class VendoController extends Controller {
 	@Get()
 	async getVendoJourneys(

backend/controllers/timetable/requests.ts

@@ -1,7 +1,7 @@
 import type { Connection, Journey } from "../../models/connection.ts";
-import mapConnection from "../../lib/mapping.ts";
 import { DateTime } from "luxon";
 import { mergeConnections } from "../../lib/merge.ts";
+import { mapConnection } from "../../lib/mapping.ts";
 
 export enum RequestType {
 	DEPARTURES = "departures",

backend/lib/mapping.ts

@@ -4,6 +4,7 @@ import { DateTime } from "luxon";
 import type { Stop } from "../models/station.ts";
 import type { Message } from "../models/message.ts";
 import { mapToProduct } from "../models/products.ts";
+import type { Sequence } from "../models/sequence.ts";
 
 const mapConnection = (entry: any, type: "departures" | "arrivals", profile: "db" | "dbnav"): Connection => {
 	const delay: number = calculateDuration(
@@ -96,4 +97,54 @@ const mapMessages = (
 	};
 };
 
-export default mapConnection;
+const mapCoachSequence = (entry: any): Sequence => {
+	return {
+		track: {
+			start: { position: entry?.gleis?.start?.position },
+			end: { position: entry?.gleis?.ende?.position },
+			sections: entry?.gleis?.sektoren?.map((rawSection: any) => ({
+				name: rawSection?.bezeichnung,
+				start: { position: rawSection?.start?.position },
+				end: { position: rawSection?.ende?.position },
+				gleisabschnittswuerfelPosition: rawSection?.gleisabschnittswuerfelPosition,
+				firstClass: rawSection?.ersteKlasse
+			})),
+			name: entry?.gleis?.bezeichnung
+		},
+		vehicleGroup: entry?.fahrzeuggruppen?.map((rawGroup: any) => ({
+			vehicles: rawGroup?.fahrzeuge?.map((rawVehicle: any) => ({
+				vehicleType: {
+					category: rawVehicle?.fahrzeugtyp?.fahrzeugkategorie,
+					model: rawVehicle?.fahrzeugtyp?.baureihe,
+					firstClass: rawVehicle?.fahrzeugtyp?.ersteKlasse,
+					secondClass: rawVehicle?.fahrzeugtyp?.zweiteKlasse
+				},
+				status: rawVehicle?.status,
+				orientation: rawVehicle?.orientierung,
+				positionOnTrack: {
+					start: { position: rawVehicle?.positionAmGleis?.start?.position },
+					end: { position: rawVehicle?.positionAmGleis?.ende?.position },
+					section: rawVehicle?.positionAmGleis?.sektor
+				},
+				equipment: rawVehicle?.ausstattungsmerkmale?.map((rawEquipment: any) => ({
+					type: rawEquipment?.art,
+					status: rawEquipment?.status
+				})),
+				orderNumber: rawVehicle?.ordnungsnummer
+			})),
+			tripReference: {
+				type: rawGroup?.fahrtreferenz?.typ,
+				line: rawGroup?.fahrtreferenz?.linie,
+				destination: { name: rawGroup?.fahrtreferenz?.ziel.bezeichnung },
+				category: rawGroup?.fahrtreferenz?.gattung,
+				fahrtNr: rawGroup?.fahrtreferenz?.fahrtnummer
+			},
+			designation: rawGroup?.bezeichnung
+		})),
+		direction: entry?.fahrtrichtung === "RECHTS" ? "RIGHT" : "LEFT",
+		plannedTrack: entry?.gleisSoll,
+		actualTrack: entry?.gleisVorschau
+	}
+}
+
+export { mapConnection, mapCoachSequence };

backend/models/sequence.ts

@@ -0,0 +1,85 @@
+export interface Sequence {
+	track: Track;
+	vehicleGroup?: VehicleGroup[];
+	direction?: "RIGHT" | "LEFT";
+	plannedTrack?: string;
+	actualTrack?: string;
+}
+
+export interface Track {
+	start: { position: number };
+	end: { position: number };
+	sections: Section[] | [];
+	name: string; // name of the track
+}
+
+export interface Section {
+	name: string;
+	start: { position: number };
+	end: { position: number };
+	gleisabschnittswuerfelPosition: number; // ??????????????????????
+	firstClass: boolean;
+}
+
+export interface VehicleGroup {
+	vehicles: Vehicle[];
+	tripReference: TripReference;
+	designation: string;
+}
+
+export interface TripReference {
+	type: string;
+	line: string;
+	destination: { name: string; };
+	category: string;
+	fahrtNr: number;
+}
+
+export interface Vehicle {
+	vehicleType: VehicleType;
+	status: string;
+	orientation: string;
+	positionOnTrack: PositionOnTrack;
+	equipment: Equipment[];
+	orderNumber?: number; // coach number
+}
+
+/**
+ * category might be:
+ *
+ * POWERCAR
+ * LOCOMOTIVE
+ * DOUBLEDECK_*
+ * PASSENGERCARRIAGE_*
+ */
+export interface VehicleType {
+	category: string;
+	model: string;
+	firstClass: boolean;
+	secondClass: boolean;
+}
+
+export interface PositionOnTrack {
+	start: { position: number };
+	end: { position: number };
+	section: string;
+}
+
+/**
+ * SEATS_SEVERELY_DISABLED
+ * ZONE_FAMILY
+ * ZONE_QUIET
+ * INFO
+ * CABIN_INFANT
+ * AIR_CONDITION
+ * TOILET_WHEELCHAIR
+ * WHEELCHAIR_SPACE
+ * SEATS_BAHN_COMFORT
+ * BIKE_SPACE
+ * ZONE_MULTI_PURPOSE
+ * BISTRO
+ */
+export interface Equipment {
+	type: string;
+	status: string;
+}

backend/package.json

@@ -1,5 +1,5 @@
 {
-	"name": "backend",
+	"name": "Navigator Backend",
 	"module": "server.ts",
 	"type": "module",
 	"scripts": {

backend/server.ts

@@ -10,6 +10,8 @@ app.use(express.json());
 app.use(cors({ origin: "*" }));
 
 app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocument));
+app.get("/api-spec", (req, res) => res.download("./build/swagger.json"));
+app.get("/api", (req, res) => res.redirect("/api-docs"));
 
 RegisterRoutes(app);