Merge pull request #109 from Tria-plc/freight/feature/add_train_routing

Freight/feature/add train routing

apps/edr-freight-api/src/app.module.ts

@@ -47,6 +47,7 @@ import { TrainsModule } from "./modules/trains/trains.module";
 import { WagonsModule } from './modules/wagons/wagons.module';
 import { ContainersModule } from './modules/container-management/containers.module';
 import { CargoesModule } from './modules/cargoes/cargoes.module';
+import { RoutesModule } from './modules/routes/routes.module';
 
 @Module({
   imports: [
@@ -98,6 +99,7 @@ import { CargoesModule } from './modules/cargoes/cargoes.module';
     WagonsModule,
     ContainersModule,
     CargoesModule,
+    RoutesModule,
   ],
   providers: [EdrOrgSeeder, DemoUsersSeeder,FreightStaffUsersSeeder, DemoBookingsSeeder, PricingDataSeeder, FileUploadSettingsSeeder],
 })

apps/edr-freight-api/src/data-source.ts

@@ -1,14 +1,15 @@
 // apps/edr-freight-api/src/data-source.ts
+import 'dotenv/config';
 import { DataSource } from 'typeorm';
 //import { ensurePostgresSchemas } from './utils/ensure-postgres-schemas'; // adjust path if needed
 
 export const AppDataSource = new DataSource({
   type: 'postgres',
-  host: 'localhost',
+  host: process.env.DB_HOST ?? 'localhost',
-  port: 5432,
+  port: Number(process.env.DB_PORT ?? 5432),
-  username: 'postgres',
+  username: process.env.DB_USER ?? 'postgres',
-  password: '', // Laragon default: empty
+  password: process.env.DB_PASSWORD ?? '',
-  database: 'edr_freight',
+  database: process.env.DB_NAME ?? 'edr_freight',
   schema: 'freight', // default schema for entities without an explicit schema
   entities: [__dirname + '/**/*.entity{.ts,.js}'],
   migrations: [__dirname + '/migrations/*{.ts,.js}'],

apps/edr-freight-api/src/migrations/1750100000000-AddRoutesAndExtendLocomotives.ts

@@ -0,0 +1,87 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddRoutesAndExtendLocomotives1750100000000 implements MigrationInterface {
+  name = 'AddRoutesAndExtendLocomotives1750100000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.locomotives
+      ADD COLUMN IF NOT EXISTS locomotive_type VARCHAR(20) NOT NULL DEFAULT 'DIESEL',
+      ADD COLUMN IF NOT EXISTS max_train_length_meters NUMERIC(10,3) NOT NULL DEFAULT 760,
+      ADD COLUMN IF NOT EXISTS power_kw NUMERIC(10,3) NULL,
+      ADD COLUMN IF NOT EXISTS traction_force_kn NUMERIC(10,3) NULL,
+      ADD COLUMN IF NOT EXISTS max_speed_kmh NUMERIC(10,3) NULL;
+    `);
+
+    await queryRunner.query(`
+      UPDATE freight.locomotives
+      SET status = 'OUT_OF_SERVICE'
+      WHERE status = 'INACTIVE';
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.routes (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name VARCHAR(120) NOT NULL UNIQUE,
+        origin_yard_id UUID NOT NULL REFERENCES freight.yards(id),
+        destination_yard_id UUID NOT NULL REFERENCES freight.yards(id),
+        is_active BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.route_milestones (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        route_id UUID NOT NULL REFERENCES freight.routes(id) ON DELETE CASCADE,
+        yard_id UUID NOT NULL REFERENCES freight.yards(id),
+        sequence_no INT NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        deleted_at TIMESTAMPTZ NULL,
+        CONSTRAINT uq_route_milestones_route_sequence UNIQUE (route_id, sequence_no)
+      );
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_routes_origin_yard_id
+      ON freight.routes(origin_yard_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_routes_destination_yard_id
+      ON freight.routes(destination_yard_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_routes_is_active
+      ON freight.routes(is_active);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_route_milestones_route_id
+      ON freight.route_milestones(route_id);
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_route_milestones_yard_id
+      ON freight.route_milestones(yard_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.route_milestones;`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.routes;`);
+    await queryRunner.query(`
+      ALTER TABLE freight.locomotives
+      DROP COLUMN IF EXISTS max_speed_kmh,
+      DROP COLUMN IF EXISTS traction_force_kn,
+      DROP COLUMN IF EXISTS power_kw,
+      DROP COLUMN IF EXISTS max_train_length_meters,
+      DROP COLUMN IF EXISTS locomotive_type;
+    `);
+    await queryRunner.query(`
+      UPDATE freight.locomotives
+      SET status = 'INACTIVE'
+      WHERE status = 'OUT_OF_SERVICE';
+    `);
+  }
+}

apps/edr-freight-api/src/migrations/1750300000000-AddRouteToTrainSchedules.ts

@@ -0,0 +1,44 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddRouteToTrainSchedules1750300000000 implements MigrationInterface {
+  name = 'AddRouteToTrainSchedules1750300000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+      ADD COLUMN IF NOT EXISTS route_id UUID NULL;
+    `);
+
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'fk_train_schedules_route'
+        ) THEN
+          ALTER TABLE freight.train_schedules
+          ADD CONSTRAINT fk_train_schedules_route
+          FOREIGN KEY (route_id) REFERENCES freight.routes(id);
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_train_schedules_route_id
+      ON freight.train_schedules(route_id);
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_train_schedules_route_id;`);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+      DROP CONSTRAINT IF EXISTS fk_train_schedules_route;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE freight.train_schedules
+      DROP COLUMN IF EXISTS route_id;
+    `);
+  }
+}

apps/edr-freight-api/src/modules/locomotives/dto/create-locomotive.dto.ts

@@ -0,0 +1,59 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsIn, IsNumber, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+import { LOCOMOTIVE_STATUSES, LOCOMOTIVE_TYPES } from '../entities/locomotive.entity';
+
+export class CreateLocomotiveDto {
+  @ApiProperty({ example: 'LOCO-001' })
+  @IsString()
+  @MaxLength(32)
+  code!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  name?: string;
+
+  @ApiProperty({ enum: LOCOMOTIVE_TYPES })
+  @IsIn([...LOCOMOTIVE_TYPES])
+  locomotiveType!: string;
+
+  @ApiProperty({ enum: LOCOMOTIVE_STATUSES })
+  @IsIn([...LOCOMOTIVE_STATUSES])
+  status!: string;
+
+  @ApiProperty({ example: 3500 })
+  @Transform(({ value }) => Number(value))
+  @IsNumber()
+  @Min(0)
+  maxPullWeightTons!: number;
+
+  @ApiProperty({ example: 760 })
+  @Transform(({ value }) => Number(value))
+  @IsNumber()
+  @Min(0)
+  maxTrainLengthMeters!: number;
+
+  @ApiPropertyOptional({ example: 4200 })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  powerKw?: number;
+
+  @ApiPropertyOptional({ example: 300 })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  tractionForceKn?: number;
+
+  @ApiPropertyOptional({ example: 120 })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  @IsNumber()
+  @Min(0)
+  maxSpeedKmh?: number;
+}

apps/edr-freight-api/src/modules/locomotives/dto/filter-locomotives.dto.ts

@@ -1,11 +1,16 @@
 import { ApiPropertyOptional } from '@nestjs/swagger';
 import { IsIn, IsOptional } from 'class-validator';
 
-import { LOCOMOTIVE_STATUSES } from '../entities/locomotive.entity';
+import { LOCOMOTIVE_STATUSES, LOCOMOTIVE_TYPES } from '../entities/locomotive.entity';
 
 export class FilterLocomotivesDto {
   @ApiPropertyOptional({ enum: LOCOMOTIVE_STATUSES })
   @IsOptional()
   @IsIn([...LOCOMOTIVE_STATUSES])
   status?: string;
+
+  @ApiPropertyOptional({ enum: LOCOMOTIVE_TYPES })
+  @IsOptional()
+  @IsIn([...LOCOMOTIVE_TYPES])
+  locomotiveType?: string;
 }

apps/edr-freight-api/src/modules/locomotives/dto/update-locomotive.dto.ts

@@ -0,0 +1,5 @@
+import { PartialType } from '@nestjs/swagger';
+
+import { CreateLocomotiveDto } from './create-locomotive.dto';
+
+export class UpdateLocomotiveDto extends PartialType(CreateLocomotiveDto) {}

apps/edr-freight-api/src/modules/locomotives/entities/locomotive.entity.ts

@@ -7,10 +7,13 @@ export const LOCOMOTIVE_STATUSES = [
   'AVAILABLE',
   'ASSIGNED',
   'MAINTENANCE',
-  'INACTIVE',
+  'OUT_OF_SERVICE',
 ] as const;
 
+export const LOCOMOTIVE_TYPES = ['DIESEL', 'ELECTRIC'] as const;
+
 export type LocomotiveStatus = (typeof LOCOMOTIVE_STATUSES)[number];
+export type LocomotiveType = (typeof LOCOMOTIVE_TYPES)[number];
 
 @Entity({ schema: 'freight', name: 'locomotives' })
 @Index(['code'])
@@ -22,14 +25,26 @@ export class Locomotive extends BaseEntity {
   @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
   name?: string | null;
 
+  @Column({ name: 'locomotive_type', type: 'varchar', length: 20, default: 'DIESEL' })
+  locomotiveType!: LocomotiveType;
+
   @Column({ name: 'max_pull_weight_tons', type: 'numeric', precision: 10, scale: 3 })
   maxPullWeightTons!: number;
 
+  @Column({ name: 'max_train_length_meters', type: 'numeric', precision: 10, scale: 3, default: 760 })
+  maxTrainLengthMeters!: number;
+
   @Column({ name: 'status', type: 'varchar', length: 20, default: 'AVAILABLE' })
   status!: LocomotiveStatus;
 
-  @Column({ name: 'available_from', type: 'timestamptz', nullable: true })
+  @Column({ name: 'power_kw', type: 'numeric', precision: 10, scale: 3, nullable: true })
-  availableFrom?: Date | null;
+  powerKw?: number | null;
+
+  @Column({ name: 'traction_force_kn', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  tractionForceKn?: number | null;
+
+  @Column({ name: 'max_speed_kmh', type: 'numeric', precision: 10, scale: 3, nullable: true })
+  maxSpeedKmh?: number | null;
 
   @OneToMany(() => TrainSet, (trainSet) => trainSet.locomotive)
   trainSets?: TrainSet[];

apps/edr-freight-api/src/modules/locomotives/locomotives.controller.ts

@@ -1,7 +1,9 @@
-import { Controller, Get, Query } from '@nestjs/common';
+import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
+import { CreateLocomotiveDto } from './dto/create-locomotive.dto';
 import { FilterLocomotivesDto } from './dto/filter-locomotives.dto';
+import { UpdateLocomotiveDto } from './dto/update-locomotive.dto';
 import { LocomotivesService } from './locomotives.service';
 
 @ApiTags('locomotives')
@@ -15,4 +17,28 @@ export class LocomotivesController {
   findAll(@Query() filter: FilterLocomotivesDto) {
     return this.locomotivesService.findAll(filter);
   }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a locomotive by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.locomotivesService.findById(id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create a locomotive' })
+  create(@Body() dto: CreateLocomotiveDto) {
+    return this.locomotivesService.create(dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update a locomotive' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateLocomotiveDto) {
+    return this.locomotivesService.update(id, dto);
+  }
+
+  @Post(':id/decommission')
+  @ApiOperation({ summary: 'Decommission a locomotive' })
+  decommission(@Param('id', ParseUUIDPipe) id: string) {
+    return this.locomotivesService.decommission(id);
+  }
 }

apps/edr-freight-api/src/modules/locomotives/locomotives.service.ts

@@ -1,7 +1,9 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { ConflictException, Injectable, NotFoundException } from '@nestjs/common';
 
+import { CreateLocomotiveDto } from './dto/create-locomotive.dto';
 import { FilterLocomotivesDto } from './dto/filter-locomotives.dto';
-import { Locomotive, type LocomotiveStatus } from './entities/locomotive.entity';
+import { UpdateLocomotiveDto } from './dto/update-locomotive.dto';
+import { Locomotive, type LocomotiveStatus, type LocomotiveType } from './entities/locomotive.entity';
 import { LocomotivesRepository } from './locomotives.repository';
 
 @Injectable()
@@ -10,13 +12,36 @@ export class LocomotivesService {
 
   findAll(filter: FilterLocomotivesDto): Promise<Locomotive[]> {
     return this.locomotivesRepository.findAll({
-      where: filter.status
+      where: {
-        ? { status: filter.status as LocomotiveStatus }
+        ...(filter.status ? { status: filter.status as LocomotiveStatus } : {}),
-        : undefined,
+        ...(filter.locomotiveType
+          ? { locomotiveType: filter.locomotiveType as LocomotiveType }
+          : {}),
+      },
       order: { code: 'ASC' },
     });
   }
 
+  async create(dto: CreateLocomotiveDto): Promise<Locomotive> {
+    const [existing] = await this.locomotivesRepository.findAll({ where: { code: dto.code } });
+
+    if (existing) {
+      throw new ConflictException(`Locomotive code ${dto.code} already exists`);
+    }
+
+    return this.locomotivesRepository.create({
+      code: dto.code,
+      name: dto.name?.trim() || null,
+      locomotiveType: dto.locomotiveType as LocomotiveType,
+      status: dto.status as LocomotiveStatus,
+      maxPullWeightTons: dto.maxPullWeightTons,
+      maxTrainLengthMeters: dto.maxTrainLengthMeters,
+      powerKw: dto.powerKw ?? null,
+      tractionForceKn: dto.tractionForceKn ?? null,
+      maxSpeedKmh: dto.maxSpeedKmh ?? null,
+    });
+  }
+
   async findById(id: string): Promise<Locomotive> {
     const locomotive = await this.locomotivesRepository.findById(id);
 
@@ -26,4 +51,48 @@ export class LocomotivesService {
 
     return locomotive;
   }
+
+  async update(id: string, dto: UpdateLocomotiveDto): Promise<Locomotive> {
+    const locomotive = await this.findById(id);
+
+    if (dto.code && dto.code !== locomotive.code) {
+      const [existing] = await this.locomotivesRepository.findAll({ where: { code: dto.code } });
+      if (existing && existing.id !== id) {
+        throw new ConflictException(`Locomotive code ${dto.code} already exists`);
+      }
+    }
+
+    const updated = await this.locomotivesRepository.update(id, {
+      ...dto,
+      locomotiveType:
+        dto.locomotiveType === undefined ? locomotive.locomotiveType : dto.locomotiveType as LocomotiveType,
+      status: dto.status === undefined ? locomotive.status : dto.status as LocomotiveStatus,
+      name: dto.name === undefined ? locomotive.name : dto.name?.trim() || null,
+      powerKw: dto.powerKw === undefined ? locomotive.powerKw : dto.powerKw ?? null,
+      tractionForceKn:
+        dto.tractionForceKn === undefined ? locomotive.tractionForceKn : dto.tractionForceKn ?? null,
+      maxSpeedKmh:
+        dto.maxSpeedKmh === undefined ? locomotive.maxSpeedKmh : dto.maxSpeedKmh ?? null,
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Locomotive ${id} not found`);
+    }
+
+    return updated;
+  }
+
+  async decommission(id: string): Promise<Locomotive> {
+    await this.findById(id);
+
+    const updated = await this.locomotivesRepository.update(id, {
+      status: 'OUT_OF_SERVICE',
+    });
+
+    if (!updated) {
+      throw new NotFoundException(`Locomotive ${id} not found`);
+    }
+
+    return updated;
+  }
 }

apps/edr-freight-api/src/modules/routes/dto/create-route.dto.ts

@@ -0,0 +1,28 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { ArrayMinSize, IsArray, IsBoolean, IsOptional, IsString, IsUUID, MaxLength, ValidateNested } from 'class-validator';
+
+export class CreateRouteMilestoneDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  yardId!: string;
+}
+
+export class CreateRouteDto {
+  @ApiProperty()
+  @IsString()
+  @MaxLength(120)
+  name!: string;
+
+  @ApiProperty({ type: [CreateRouteMilestoneDto] })
+  @IsArray()
+  @ArrayMinSize(2)
+  @ValidateNested({ each: true })
+  @Type(() => CreateRouteMilestoneDto)
+  milestones!: CreateRouteMilestoneDto[];
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

apps/edr-freight-api/src/modules/routes/dto/filter-routes.dto.ts

@@ -0,0 +1,16 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+export class FilterRoutesDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @Transform(({ value }) => value === 'true' || value === true)
+  @IsBoolean()
+  isActive?: boolean;
+}

apps/edr-freight-api/src/modules/routes/dto/update-route.dto.ts

@@ -0,0 +1,5 @@
+import { PartialType } from '@nestjs/swagger';
+
+import { CreateRouteDto } from './create-route.dto';
+
+export class UpdateRouteDto extends PartialType(CreateRouteDto) {}

apps/edr-freight-api/src/modules/routes/entities/route-milestone.entity.ts

@@ -0,0 +1,26 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { Yard } from '../../rule-engine/entities/yard.entity';
+import { Route } from './route.entity';
+
+@Entity({ schema: 'freight', name: 'route_milestones' })
+@Index(['routeId', 'sequenceNo'], { unique: true })
+export class RouteMilestone extends BaseEntity {
+  @Column({ name: 'route_id', type: 'uuid' })
+  routeId!: string;
+
+  @ManyToOne(() => Route, (route) => route.milestones, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'route_id' })
+  route?: Route;
+
+  @Column({ name: 'yard_id', type: 'uuid' })
+  yardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'yard_id' })
+  yard?: Yard;
+
+  @Column({ name: 'sequence_no', type: 'int' })
+  sequenceNo!: number;
+}

apps/edr-freight-api/src/modules/routes/entities/route.entity.ts

@@ -0,0 +1,33 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+
+import { Yard } from '../../rule-engine/entities/yard.entity';
+import { RouteMilestone } from './route-milestone.entity';
+
+@Entity({ schema: 'freight', name: 'routes' })
+@Index(['name'])
+@Index(['isActive'])
+export class Route extends BaseEntity {
+  @Column({ name: 'name', type: 'varchar', length: 120, unique: true })
+  name!: string;
+
+  @Column({ name: 'origin_yard_id', type: 'uuid' })
+  originYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'origin_yard_id' })
+  originYard?: Yard;
+
+  @Column({ name: 'destination_yard_id', type: 'uuid' })
+  destinationYardId!: string;
+
+  @ManyToOne(() => Yard)
+  @JoinColumn({ name: 'destination_yard_id' })
+  destinationYard?: Yard;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+
+  @OneToMany(() => RouteMilestone, (milestone) => milestone.route, { cascade: false })
+  milestones?: RouteMilestone[];
+}

apps/edr-freight-api/src/modules/routes/route-milestones.repository.ts

@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { RouteMilestone } from './entities/route-milestone.entity';
+
+@Injectable()
+export class RouteMilestonesRepository extends BaseRepository<RouteMilestone> {
+  constructor(@InjectRepository(RouteMilestone) repository: Repository<RouteMilestone>) {
+    super(repository);
+  }
+}

apps/edr-freight-api/src/modules/routes/routes.controller.ts

@@ -0,0 +1,44 @@
+import { Body, Controller, Delete, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { CreateRouteDto } from './dto/create-route.dto';
+import { FilterRoutesDto } from './dto/filter-routes.dto';
+import { UpdateRouteDto } from './dto/update-route.dto';
+import { RoutesService } from './routes.service';
+
+@ApiTags('routes')
+@ApiBearerAuth()
+@Controller('routes')
+export class RoutesController {
+  constructor(private readonly routesService: RoutesService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List routes' })
+  findAll(@Query() filter: FilterRoutesDto) {
+    return this.routesService.findAll(filter);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get route by ID' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.routesService.findById(id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Create route' })
+  create(@Body() dto: CreateRouteDto) {
+    return this.routesService.create(dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Update route' })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateRouteDto) {
+    return this.routesService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @ApiOperation({ summary: 'Deactivate route' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.routesService.deactivate(id);
+  }
+}

apps/edr-freight-api/src/modules/routes/routes.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { Yard } from '../rule-engine/entities/yard.entity';
+import { RouteMilestone } from './entities/route-milestone.entity';
+import { Route } from './entities/route.entity';
+import { RouteMilestonesRepository } from './route-milestones.repository';
+import { RoutesController } from './routes.controller';
+import { RoutesRepository } from './routes.repository';
+import { RoutesService } from './routes.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Route, RouteMilestone, Yard])],
+  controllers: [RoutesController],
+  providers: [RoutesRepository, RouteMilestonesRepository, RoutesService],
+  exports: [RoutesRepository, RouteMilestonesRepository, RoutesService],
+})
+export class RoutesModule {}

apps/edr-freight-api/src/modules/routes/routes.repository.ts

@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { Route } from './entities/route.entity';
+
+@Injectable()
+export class RoutesRepository extends BaseRepository<Route> {
+  constructor(@InjectRepository(Route) repository: Repository<Route>) {
+    super(repository);
+  }
+}

apps/edr-freight-api/src/modules/routes/routes.service.ts

@@ -0,0 +1,171 @@
+import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { DataSource, ILike } from 'typeorm';
+
+import { Yard } from '../rule-engine/entities/yard.entity';
+import { CreateRouteDto } from './dto/create-route.dto';
+import { FilterRoutesDto } from './dto/filter-routes.dto';
+import { UpdateRouteDto } from './dto/update-route.dto';
+import { RouteMilestone } from './entities/route-milestone.entity';
+import { Route } from './entities/route.entity';
+import { RoutesRepository } from './routes.repository';
+
+@Injectable()
+export class RoutesService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly routesRepository: RoutesRepository,
+  ) {}
+
+  findAll(filter: FilterRoutesDto): Promise<Route[]> {
+    return this.routesRepository.findAll({
+      where: {
+        ...(filter.search ? { name: ILike(`%${filter.search.trim()}%`) } : {}),
+        ...(filter.isActive !== undefined ? { isActive: filter.isActive } : {}),
+      },
+      relations: {
+        originYard: true,
+        destinationYard: true,
+        milestones: { yard: true },
+      },
+      order: {
+        name: 'ASC',
+        milestones: { sequenceNo: 'ASC' },
+      },
+    });
+  }
+
+  async findById(id: string): Promise<Route> {
+    const route = await this.dataSource.getRepository(Route).findOne({
+      where: { id },
+      relations: {
+        originYard: true,
+        destinationYard: true,
+        milestones: { yard: true },
+      },
+      order: { milestones: { sequenceNo: 'ASC' } },
+    });
+
+    if (!route) {
+      throw new NotFoundException(`Route ${id} not found`);
+    }
+
+    return route;
+  }
+
+  async create(dto: CreateRouteDto): Promise<Route> {
+    await this.validateRouteName(dto.name);
+    const validated = await this.validateMilestones(dto.milestones);
+
+    const route = await this.dataSource.transaction(async (manager) => {
+      const savedRoute = await manager.getRepository(Route).save(
+        manager.getRepository(Route).create({
+          name: dto.name.trim(),
+          originYardId: validated.originYardId,
+          destinationYardId: validated.destinationYardId,
+          isActive: dto.isActive ?? true,
+        }),
+      );
+
+      await manager.getRepository(RouteMilestone).save(
+        validated.milestones.map((milestone) =>
+          manager.getRepository(RouteMilestone).create({
+            routeId: savedRoute.id,
+            yardId: milestone.yardId,
+            sequenceNo: milestone.sequenceNo,
+          }),
+        ),
+      );
+
+      return savedRoute;
+    });
+
+    return this.findById(route.id);
+  }
+
+  async update(id: string, dto: UpdateRouteDto): Promise<Route> {
+    const existing = await this.findById(id);
+
+    if (dto.name && dto.name.trim() !== existing.name) {
+      await this.validateRouteName(dto.name, id);
+    }
+
+    const milestoneInput = dto.milestones
+      ? await this.validateMilestones(dto.milestones)
+      : null;
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(Route).update(id, {
+        name: dto.name?.trim() ?? existing.name,
+        originYardId: milestoneInput?.originYardId ?? existing.originYardId,
+        destinationYardId: milestoneInput?.destinationYardId ?? existing.destinationYardId,
+        isActive: dto.isActive ?? existing.isActive,
+      });
+
+      if (milestoneInput) {
+        await manager.getRepository(RouteMilestone).delete({ routeId: id });
+        await manager.getRepository(RouteMilestone).save(
+          milestoneInput.milestones.map((milestone) =>
+            manager.getRepository(RouteMilestone).create({
+              routeId: id,
+              yardId: milestone.yardId,
+              sequenceNo: milestone.sequenceNo,
+            }),
+          ),
+        );
+      }
+    });
+
+    return this.findById(id);
+  }
+
+  async deactivate(id: string): Promise<Route> {
+    await this.findById(id);
+    const updated = await this.routesRepository.update(id, { isActive: false });
+
+    if (!updated) {
+      throw new NotFoundException(`Route ${id} not found`);
+    }
+
+    return this.findById(id);
+  }
+
+  private async validateRouteName(name: string, routeId?: string) {
+    const trimmedName = name.trim();
+    const [existing] = await this.routesRepository.findAll({ where: { name: trimmedName } });
+
+    if (existing && existing.id !== routeId) {
+      throw new ConflictException(`Route name ${trimmedName} already exists`);
+    }
+  }
+
+  private async validateMilestones(milestones: Array<{ yardId: string }>) {
+    if (milestones.length < 2) {
+      throw new BadRequestException('A route requires at least two yards');
+    }
+
+    const normalized = milestones.map((milestone, index) => ({
+      yardId: milestone.yardId,
+      sequenceNo: index + 1,
+    }));
+
+    const uniqueYardIds = [...new Set(normalized.map((milestone) => milestone.yardId))];
+    const yards = await this.dataSource.getRepository(Yard).find({ where: uniqueYardIds.map((id) => ({ id })) });
+    const yardIds = new Set(yards.map((yard) => yard.id));
+
+    for (const milestone of normalized) {
+      if (!yardIds.has(milestone.yardId)) {
+        throw new BadRequestException(`Yard ${milestone.yardId} does not exist`);
+      }
+    }
+
+    if (normalized[0].yardId === normalized[normalized.length - 1].yardId) {
+      throw new BadRequestException('Origin and destination yards must be different');
+    }
+
+    return {
+      originYardId: normalized[0].yardId,
+      destinationYardId: normalized[normalized.length - 1].yardId,
+      milestones: normalized,
+    };
+  }
+}

apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts

@@ -2,6 +2,7 @@ import { BaseEntity } from '@edr/api-common';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany, OneToOne } from 'typeorm';
 
 import { Yard } from '../../rule-engine/entities/yard.entity';
+import { Route } from '../../routes/entities/route.entity';
 import { TrainSet } from '../../train-sets/entities/train-set.entity';
 import { TrainScheduleBooking } from './train-schedule-booking.entity';
 
@@ -26,6 +27,13 @@ export class TrainSchedule extends BaseEntity {
   @JoinColumn({ name: 'train_set_id' })
   trainSet?: TrainSet;
 
+  @Column({ name: 'route_id', type: 'uuid', nullable: true })
+  routeId?: string | null;
+
+  @ManyToOne(() => Route)
+  @JoinColumn({ name: 'route_id' })
+  route?: Route | null;
+
   @Column({ name: 'origin_station_id', type: 'uuid' })
   originStationId!: string;
 

apps/edr-freight-api/src/modules/train-scheduling/dto/create-container-train-schedule.dto.ts

@@ -1,9 +1,15 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsUUID } from 'class-validator';
+import { IsDateString, IsUUID } from 'class-validator';
 
-import { PreviewContainerTrainScheduleDto } from './preview-container-train-schedule.dto';
+export class CreateContainerTrainScheduleDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  routeId!: string;
+
+  @ApiProperty({ example: '2026-06-20T08:00:00.000Z' })
+  @IsDateString()
+  scheduleDate!: string;
 
-export class CreateContainerTrainScheduleDto extends PreviewContainerTrainScheduleDto {
   @ApiProperty({ format: 'uuid' })
   @IsUUID()
   locomotiveId!: string;

apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts

@@ -17,6 +17,7 @@ const locomotive = {
   id: 'loc-1',
   code: 'LOC-001',
   maxPullWeightTons: 3500,
+  maxTrainLengthMeters: 760,
   status: 'AVAILABLE',
 };
 
@@ -202,47 +203,12 @@ describe('TrainSchedulingService', () => {
   });
 
   it('creates a schedule transactionally when validation passes', async () => {
-    const bookings = [makeBooking('b1', 'BKG-CONT-001', 140, 2, '40FT')];
+    const route = {
-    const validation = {
+      id: 'route-1',
-      valid: true,
+      name: 'Djibouti to Addis',
-      violations: [],
+      originYardId: 'yard-origin',
-      bookings,
+      destinationYardId: 'yard-destination',
-      wagonType: nw5,
+      isActive: true,
-      summary: {
-        totalBookings: 1,
-        totalWeightTons: 140,
-        wagonType: 'NW5',
-        wagonsNeeded: 2,
-        totalLengthMeters: 28,
-      },
-      wagonPlan: [
-        {
-          sequenceNo: 1,
-          capacityTons: 70,
-          lengthMeters: 14,
-          assignedWeightTons: 70,
-          allocations: [
-            {
-              bookingId: 'b1',
-              bookingReference: 'BKG-CONT-001',
-              allocatedWeightTons: 70,
-            },
-          ],
-        },
-        {
-          sequenceNo: 2,
-          capacityTons: 70,
-          lengthMeters: 14,
-          assignedWeightTons: 70,
-          allocations: [
-            {
-              bookingId: 'b1',
-              bookingReference: 'BKG-CONT-001',
-              allocatedWeightTons: 70,
-            },
-          ],
-        },
-      ],
     };
 
     const lockedLocomotiveRepo = {
@@ -253,23 +219,6 @@ describe('TrainSchedulingService', () => {
       create: jest.fn().mockImplementation((value) => value),
       save: jest.fn().mockResolvedValue({ id: 'schedule-1' }),
     };
-    const trainScheduleBookingRepo = {
-      count: jest.fn().mockResolvedValue(0),
-      create: jest.fn().mockImplementation((value) => value),
-      save: jest.fn().mockResolvedValue(undefined),
-    };
-    const trainSetWagonRepo = {
-      create: jest.fn().mockImplementation((value) => value),
-      save: jest.fn().mockResolvedValue(undefined),
-      find: jest.fn().mockResolvedValue([
-        { id: 'wagon-1', sequenceNo: 1 },
-        { id: 'wagon-2', sequenceNo: 2 },
-      ]),
-    };
-    const wagonAllocRepo = {
-      create: jest.fn().mockImplementation((value) => value),
-      save: jest.fn().mockResolvedValue(undefined),
-    };
     const trainSetRepo = {
       create: jest.fn().mockImplementation((value) => value),
       save: jest.fn().mockResolvedValue({ id: 'train-set-1' }),
@@ -281,12 +230,6 @@ describe('TrainSchedulingService', () => {
             return lockedLocomotiveRepo;
           case 'TrainSchedule':
             return trainScheduleRepo;
-          case 'TrainScheduleBooking':
-            return trainScheduleBookingRepo;
-          case 'TrainSetWagon':
-            return trainSetWagonRepo;
-          case 'WagonBookingAllocation':
-            return wagonAllocRepo;
           case 'TrainSet':
             return trainSetRepo;
           default:
@@ -295,70 +238,60 @@ describe('TrainSchedulingService', () => {
       }),
     };
 
-    jest.spyOn(service, 'validateContainerBookingsForScheduling').mockResolvedValue(validation as never);
     jest.spyOn(service, 'selectOrValidateLocomotive').mockResolvedValue(locomotive as never);
+    dataSource.getRepository.mockImplementation((entity: { name?: string }) => {
+      if (entity?.name === 'Route') {
+        return { findOne: jest.fn().mockResolvedValue(route) };
+      }
+      throw new Error(`Unexpected repository ${entity?.name}`);
+    });
     jest.spyOn(service, 'getContainerTrainScheduleById').mockResolvedValue({ id: 'schedule-1' } as never);
     dataSource.transaction.mockImplementation(async (callback: (tx: typeof manager) => Promise<string>) =>
       callback(manager),
     );
 
     const result = await service.createContainerTrainSchedule({
-      bookingIds: ['b1'],
+      routeId: 'route-1',
       scheduleDate: '2026-06-20T08:00:00.000Z',
-      originStationId: 'yard-origin',
-      destinationStationId: 'yard-destination',
       locomotiveId: 'loc-1',
     });
 
     expect(trainSetRepo.save).toHaveBeenCalled();
     expect(trainScheduleRepo.save).toHaveBeenCalled();
-    expect(trainSetWagonRepo.save).toHaveBeenCalled();
-    expect(wagonAllocRepo.save).toHaveBeenCalled();
     expect(lockedLocomotiveRepo.update).toHaveBeenCalledWith('loc-1', { status: 'ASSIGNED' });
     expect(result).toEqual({ id: 'schedule-1' });
   });
 
   it('rejects create when the locked locomotive is no longer available', async () => {
-    const validation = {
-      valid: true,
-      violations: [],
-      bookings: [makeBooking('b1', 'BKG-CONT-001', 70, 1, '40FT')],
-      wagonType: nw5,
-      summary: {
-        totalBookings: 1,
-        totalWeightTons: 70,
-        wagonType: 'NW5',
-        wagonsNeeded: 1,
-        totalLengthMeters: 14,
-      },
-      wagonPlan: [
-        {
-          sequenceNo: 1,
-          capacityTons: 70,
-          lengthMeters: 14,
-          assignedWeightTons: 70,
-          allocations: [],
-        },
-      ],
-    };
     const manager = {
       getRepository: jest.fn(() => ({
         findOne: jest.fn().mockResolvedValue({ ...locomotive, status: 'ASSIGNED' }),
       })),
     };
 
-    jest.spyOn(service, 'validateContainerBookingsForScheduling').mockResolvedValue(validation as never);
     jest.spyOn(service, 'selectOrValidateLocomotive').mockResolvedValue(locomotive as never);
+    dataSource.getRepository.mockImplementation((entity: { name?: string }) => {
+      if (entity?.name === 'Route') {
+        return {
+          findOne: jest.fn().mockResolvedValue({
+            id: 'route-1',
+            name: 'Djibouti to Addis',
+            originYardId: 'yard-origin',
+            destinationYardId: 'yard-destination',
+            isActive: true,
+          }),
+        };
+      }
+      throw new Error(`Unexpected repository ${entity?.name}`);
+    });
     dataSource.transaction.mockImplementation(async (callback: (tx: typeof manager) => Promise<string>) =>
       callback(manager),
     );
 
     await expect(
       service.createContainerTrainSchedule({
-        bookingIds: ['b1'],
+        routeId: 'route-1',
         scheduleDate: '2026-06-20T08:00:00.000Z',
-        originStationId: 'yard-origin',
-        destinationStationId: 'yard-destination',
         locomotiveId: 'loc-1',
       }),
     ).rejects.toBeInstanceOf(ConflictException);

apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.ts

@@ -15,9 +15,9 @@ import {
 import { LocomotivesRepository } from "../locomotives/locomotives.repository";
 import { TrainSetWagon } from "../train-sets/entities/train-set-wagon.entity";
 import { TrainSet } from "../train-sets/entities/train-set.entity";
+import { Route } from "../routes/entities/route.entity";
 import { TrainScheduleBooking } from "../train-schedules/entities/train-schedule-booking.entity";
 import { TrainSchedule } from "../train-schedules/entities/train-schedule.entity";
-import { WagonBookingAllocation } from "../train-schedules/entities/wagon-booking-allocation.entity";
 import { WagonType } from "../wagon-types/entities/wagon-type.entity";
 import { WagonTypesRepository } from "../wagon-types/wagon-types.repository";
 import { CreateContainerTrainScheduleDto } from "./dto/create-container-train-schedule.dto";
@@ -179,18 +179,12 @@ export class TrainSchedulingService {
   }
 
   async createContainerTrainSchedule(dto: CreateContainerTrainScheduleDto) {
-    const validation = await this.validateContainerBookingsForScheduling(dto);
+    const route = await this.getActiveRoute(dto.routeId);
-
-    if (!validation.valid) {
-      throw new BadRequestException({
-        message: "train_schedule_invalid",
-        violations: validation.violations,
-      });
-    }
 
     const locomotive = await this.selectOrValidateLocomotive(
       dto.locomotiveId,
-      validation.summary.totalWeightTons,
+      0,
+      0,
     );
 
     const createdSchedule = await this.dataSource.transaction(
@@ -211,90 +205,24 @@ export class TrainSchedulingService {
           );
         }
 
-        if (
+        const trainSet = await this.buildEmptyTrainSet(
-          Number(lockedLocomotive.maxPullWeightTons) <
-          validation.summary.totalWeightTons
-        ) {
-          throw new BadRequestException(
-            `Locomotive ${lockedLocomotive.code} cannot pull ${validation.summary.totalWeightTons}T`,
-          );
-        }
-
-        const existingScheduleCount = await manager
-          .getRepository(TrainScheduleBooking)
-          .count({
-            where: {
-              bookingId: In(validation.bookings.map((booking) => booking.id)),
-            },
-          });
-
-        if (existingScheduleCount > 0) {
-          throw new BadRequestException(
-            "One or more bookings are already scheduled",
-          );
-        }
-
-        const trainSet = await this.buildTrainSet(
           manager,
           lockedLocomotive,
-          validation.wagonType,
-          validation.summary.totalWeightTons,
-          validation.summary.totalLengthMeters,
-          validation.wagonPlan,
         );
 
         const schedule = manager.getRepository(TrainSchedule).create({
           trainSetId: trainSet.id,
-          originStationId: dto.originStationId,
+          routeId: route.id,
-          destinationStationId: dto.destinationStationId,
+          originStationId: route.originYardId,
+          destinationStationId: route.destinationYardId,
           scheduledDepartureDate: new Date(dto.scheduleDate),
-          status: "SCHEDULED",
+          status: "DRAFT",
         });
 
         const savedSchedule = await manager
           .getRepository(TrainSchedule)
           .save(schedule);
 
-        const scheduleBookings = validation.bookings.map((booking) =>
-          manager.getRepository(TrainScheduleBooking).create({
-            trainScheduleId: savedSchedule.id,
-            bookingId: booking.id,
-          }),
-        );
-        await manager
-          .getRepository(TrainScheduleBooking)
-          .save(scheduleBookings);
-
-        const savedWagons = await manager.getRepository(TrainSetWagon).find({
-          where: { trainSetId: trainSet.id },
-          order: { sequenceNo: "ASC" },
-        });
-
-        const wagonBySequence = new Map(
-          savedWagons.map((wagon) => [wagon.sequenceNo, wagon]),
-        );
-        const allocationRows = validation.wagonPlan.flatMap((wagonPlan) => {
-          const wagon = wagonBySequence.get(wagonPlan.sequenceNo);
-
-          if (!wagon) {
-            throw new BadRequestException(
-              `Missing wagon sequence ${wagonPlan.sequenceNo}`,
-            );
-          }
-
-          return wagonPlan.allocations.map((allocation) =>
-            manager.getRepository(WagonBookingAllocation).create({
-              trainSetWagonId: wagon.id,
-              bookingId: allocation.bookingId,
-              allocatedWeightTons: allocation.allocatedWeightTons,
-            }),
-          );
-        });
-
-        await manager
-          .getRepository(WagonBookingAllocation)
-          .save(allocationRows);
-
         await locomotiveRepository.update(lockedLocomotive.id, {
           status: "ASSIGNED",
         });
@@ -461,10 +389,14 @@ export class TrainSchedulingService {
           where: { status: "AVAILABLE" },
         });
       const canPull = capableLocomotives.some(
-        (locomotive) => Number(locomotive.maxPullWeightTons) >= totalWeightTons,
+        (locomotive) =>
+          Number(locomotive.maxPullWeightTons) >= totalWeightTons &&
+          Number(locomotive.maxTrainLengthMeters) >= totalLengthMeters,
       );
       if (!canPull) {
-        violations.push("No available locomotive can pull the total weight");
+        violations.push(
+          'No available locomotive can support the total train weight and length',
+        );
       }
     }
 
@@ -513,6 +445,7 @@ export class TrainSchedulingService {
   async selectOrValidateLocomotive(
     locomotiveId: string,
     totalWeightTons: number,
+    totalLengthMeters: number,
   ) {
     const locomotive = await this.locomotivesRepository.findById(locomotiveId);
 
@@ -532,6 +465,12 @@ export class TrainSchedulingService {
       );
     }
 
+    if (Number(locomotive.maxTrainLengthMeters) < totalLengthMeters) {
+      throw new BadRequestException(
+        `Locomotive ${locomotive.code} cannot support ${totalLengthMeters}m`,
+      );
+    }
+
     return locomotive;
   }
 
@@ -568,6 +507,21 @@ export class TrainSchedulingService {
     return savedTrainSet;
   }
 
+  async buildEmptyTrainSet(
+    manager: EntityManager,
+    locomotive: Locomotive,
+  ) {
+    const trainSet = manager.getRepository(TrainSet).create({
+      locomotiveId: locomotive.id,
+      totalWeightTons: 0,
+      totalLengthMeters: 0,
+      wagonCount: 0,
+      status: 'DRAFT',
+    });
+
+    return manager.getRepository(TrainSet).save(trainSet);
+  }
+
   allocateBookingsToWagons(
     bookings: Booking[],
     baseWagonPlan: WagonPlanRecord[],
@@ -627,6 +581,7 @@ export class TrainSchedulingService {
     const schedules = await this.dataSource.getRepository(TrainSchedule).find({
       relations: {
         trainSet: { locomotive: true },
+        route: true,
         originStation: true,
         destinationStation: true,
         scheduleBookings: true,
@@ -637,6 +592,7 @@ export class TrainSchedulingService {
     return schedules.map((schedule) => ({
       id: schedule.id,
       scheduleDate: schedule.scheduledDepartureDate,
+      routeName: schedule.route?.name ?? null,
       origin:
         schedule.originStation?.label ?? schedule.originStation?.code ?? null,
       destination:
@@ -668,6 +624,7 @@ export class TrainSchedulingService {
       .findOne({
         where: { id },
         relations: {
+          route: true,
           trainSet: {
             locomotive: true,
             wagons: { wagonType: true, allocations: { booking: true } },
@@ -687,6 +644,12 @@ export class TrainSchedulingService {
     return {
       id: schedule.id,
       status: schedule.status,
+      route: schedule.route
+        ? {
+          id: schedule.route.id,
+          name: schedule.route.name,
+        }
+        : null,
       scheduledDepartureDate: schedule.scheduledDepartureDate,
       scheduledArrivalDate: schedule.scheduledArrivalDate,
       originStation: schedule.originStation,
@@ -711,6 +674,9 @@ export class TrainSchedulingService {
               maxPullWeightTons: this.roundTons(
                 Number(schedule.trainSet.locomotive.maxPullWeightTons),
               ),
+              maxTrainLengthMeters: this.roundTons(
+                Number(schedule.trainSet.locomotive.maxTrainLengthMeters),
+              ),
             }
             : null,
           wagons: [...(schedule.trainSet.wagons ?? [])]
@@ -806,6 +772,22 @@ export class TrainSchedulingService {
     });
   }
 
+  private async getActiveRoute(routeId: string) {
+    const route = await this.dataSource.getRepository(Route).findOne({
+      where: { id: routeId },
+    });
+
+    if (!route) {
+      throw new NotFoundException(`Route ${routeId} not found`);
+    }
+
+    if (!route.isActive) {
+      throw new BadRequestException(`Route ${route.name} is inactive`);
+    }
+
+    return route;
+  }
+
   private toUtcDateKey(value: Date | string) {
     const date = value instanceof Date ? value : new Date(value);
     return date.toISOString().slice(0, 10);

apps/edr-freight-api/src/seed/demo-bookings.seeder.ts

@@ -178,13 +178,17 @@ export class DemoBookingsSeeder {
           {
             code: "LOC-001",
             name: "Demo Locomotive 1",
+            locomotiveType: 'ELECTRIC',
             maxPullWeightTons: 3500,
+            maxTrainLengthMeters: 760,
             status: "AVAILABLE",
           },
           {
             code: "LOC-002",
             name: "Demo Locomotive 2",
+            locomotiveType: 'DIESEL',
             maxPullWeightTons: 2500,
+            maxTrainLengthMeters: 760,
             status: "AVAILABLE",
           },
         ],

apps/edr-freight-web/backoffice/src/App.tsx

@@ -38,11 +38,13 @@ import TrainsPage from "./pages/trains/TrainsPage";
 import {
   CargoesCrudPage,
   ContainersCrudPage,
+  LocomotivesCrudPage,
   TrainMasterDataPage,
   WagonsCrudPage,
 } from "./pages/fleet/FleetCrudPages";
 import { getCategorySidebarChildren } from "./pages/ruleEngine/config/resources";
 import TrainDetailPage from "./pages/trains/TrainDetailPage";
+import RoutesPage from "./pages/fleet/RoutesPage";
 
 const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
   {
@@ -59,17 +61,32 @@ const buildSidebarSections = (demoItems: SidebarItem[]): SidebarSection[] => [
         href: "/dashboard/booking-requests",
         icon: <FileText />,
       },
+      ...demoItems,
+    ],
+  },
+  {
+    title: "Operations",
+    items: [
       {
-        label: "Train scheduling",
+        label: "Train Schedules",
         href: "/dashboard/operations/train-scheduling",
         icon: <Train />,
       },
-      ...demoItems,
     ],
   },
   {
     title: "Fleet Management",
     items: [
+      {
+        label: "Routes",
+        href: "/dashboard/routes",
+        icon: <Network />,
+      },
+      {
+        label: "Locomotives",
+        href: "/dashboard/locomotives",
+        icon: <Train />,
+      },
       {
         label: "Trains",
         href: "/dashboard/trains",
@@ -224,6 +241,8 @@ const App = () => {
             element={<BookingContractPage />}
           />
           <Route path="operations/train-scheduling" element={<TrainsPage />} />
+          <Route path="routes" element={<RoutesPage />} />
+          <Route path="locomotives" element={<LocomotivesCrudPage />} />
           <Route path="trains" element={<TrainMasterDataPage />} />
           <Route path="trains/:id" element={<TrainDetailPage />} />
           <Route path="wagons" element={<WagonsCrudPage />} />

apps/edr-freight-web/backoffice/src/components/layout/route-meta.ts

@@ -35,6 +35,20 @@ const ROUTE_META: Array<{ prefix: string; meta: PageMeta }> = [
       subtitle: "Dashboard summary and key metrics",
     },
   },
+  {
+    prefix: "/dashboard/routes",
+    meta: {
+      title: "Routes",
+      subtitle: "Manage route definitions built from freight yards",
+    },
+  },
+  {
+    prefix: "/dashboard/locomotives",
+    meta: {
+      title: "Locomotives",
+      subtitle: "Manage locomotive master data and service status",
+    },
+  },
   {
     prefix: "/dashboard/user-management/employees",
     meta: {

apps/edr-freight-web/backoffice/src/constants/URLS.ts

@@ -111,6 +111,13 @@ export const URL_CONSTANTS = {
 
   LOCOMOTIVES: {
     BASE: "/locomotives",
+    BY_ID: (id: string) => `/locomotives/${id}`,
+    DECOMMISSION: (id: string) => `/locomotives/${id}/decommission`,
+  },
+
+  ROUTES: {
+    BASE: '/routes',
+    BY_ID: (id: string) => `/routes/${id}`,
   },
 
   TRAIN_SCHEDULING: {

apps/edr-freight-web/backoffice/src/hooks/useLocomotives.ts

@@ -0,0 +1,47 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { locomotivesService } from '@/services/locomotives.service';
+
+export const locomotiveKeys = {
+  all: ['locomotives'] as const,
+  details: () => [...locomotiveKeys.all, 'detail'] as const,
+  detail: (id: string) => [...locomotiveKeys.details(), id] as const,
+};
+
+export function useLocomotives() {
+  return useQuery({
+    queryKey: locomotiveKeys.all,
+    queryFn: () => locomotivesService.getAll().then((response) => response.data),
+  });
+}
+
+export function useCreateLocomotive() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: locomotivesService.create,
+    onSuccess: () => qc.invalidateQueries({ queryKey: locomotiveKeys.all }),
+  });
+}
+
+export function useUpdateLocomotive() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: Record<string, unknown> }) =>
+      locomotivesService.update(id, data),
+    onSuccess: (_, { id }) => {
+      qc.invalidateQueries({ queryKey: locomotiveKeys.all });
+      qc.invalidateQueries({ queryKey: locomotiveKeys.detail(id) });
+    },
+  });
+}
+
+export function useDecommissionLocomotive() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: locomotivesService.decommission,
+    onSuccess: (_, id) => {
+      qc.invalidateQueries({ queryKey: locomotiveKeys.all });
+      qc.invalidateQueries({ queryKey: locomotiveKeys.detail(id) });
+    },
+  });
+}

apps/edr-freight-web/backoffice/src/hooks/useRoutes.ts

@@ -0,0 +1,55 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { routesService } from '@/services/routes.service';
+
+export const routeKeys = {
+  all: ['routes'] as const,
+  yards: ['routes', 'yards'] as const,
+  details: () => [...routeKeys.all, 'detail'] as const,
+  detail: (id: string) => [...routeKeys.details(), id] as const,
+};
+
+export function useRoutes() {
+  return useQuery({
+    queryKey: routeKeys.all,
+    queryFn: () => routesService.getAll().then((response) => response.data),
+  });
+}
+
+export function useRouteYards() {
+  return useQuery({
+    queryKey: routeKeys.yards,
+    queryFn: () => routesService.getYards().then((response) => response.data.data),
+  });
+}
+
+export function useCreateRoute() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: routesService.create,
+    onSuccess: () => qc.invalidateQueries({ queryKey: routeKeys.all }),
+  });
+}
+
+export function useUpdateRoute() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: Record<string, unknown> }) =>
+      routesService.update(id, data),
+    onSuccess: (_, { id }) => {
+      qc.invalidateQueries({ queryKey: routeKeys.all });
+      qc.invalidateQueries({ queryKey: routeKeys.detail(id) });
+    },
+  });
+}
+
+export function useDeactivateRoute() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: routesService.deactivate,
+    onSuccess: (_, id) => {
+      qc.invalidateQueries({ queryKey: routeKeys.all });
+      qc.invalidateQueries({ queryKey: routeKeys.detail(id) });
+    },
+  });
+}

apps/edr-freight-web/backoffice/src/pages/fleet/FleetCrudPages.tsx

@@ -27,8 +27,15 @@ import {
 } from '@/hooks/useContainers';
 import { useCreateTrain, useDeleteTrain, useTrains, useUpdateTrain } from '@/hooks/useTrains';
 import { useCreateWagon, useDeleteWagon, useUpdateWagon, useWagons } from '@/hooks/useWagons';
+import {
+  useCreateLocomotive,
+  useDecommissionLocomotive,
+  useLocomotives,
+  useUpdateLocomotive,
+} from '@/hooks/useLocomotives';
 import type { Cargo } from '@/services/cargoService';
 import type { Container } from '@/services/containerService';
+import type { Locomotive } from '@/services/locomotives.service';
 import type { Train } from '@/services/trains.service';
 import type { Wagon } from '@/services/wagon.service';
 
@@ -57,6 +64,7 @@ type FleetCrudPageProps<T extends { id: string }> = {
   title: string;
   description: string;
   addLabel: string;
+  entityLabel?: string;
   data?: T[];
   isLoading: boolean;
   columns: Column<T>[];
@@ -66,6 +74,10 @@ type FleetCrudPageProps<T extends { id: string }> = {
   create: { mutateAsync: (data: Record<string, unknown>) => Promise<unknown>; isPending: boolean };
   update: { mutateAsync: (data: { id: string; data: Record<string, unknown> }) => Promise<unknown>; isPending: boolean };
   remove: { mutateAsync: (id: string) => Promise<unknown>; isPending: boolean };
+  removeActionLabel?: string;
+  removeConfirmMessage?: string;
+  removeSuccessMessage?: string;
+  hideViewAction?: boolean;
 };
 
 const normalizePayload = (values: Record<string, FormValue>) =>
@@ -121,6 +133,7 @@ function FleetCrudPage<T extends { id: string }>({
   title,
   description,
   addLabel,
+  entityLabel,
   data,
   isLoading,
   columns,
@@ -130,6 +143,10 @@ function FleetCrudPage<T extends { id: string }>({
   create,
   update,
   remove,
+  removeActionLabel = 'Delete',
+  removeConfirmMessage,
+  removeSuccessMessage,
+  hideViewAction = false,
 }: FleetCrudPageProps<T>) {
   const [search, setSearch] = useState('');
   const [page, setPage] = useState(1);
@@ -228,12 +245,13 @@ function FleetCrudPage<T extends { id: string }>({
   };
 
   const handleDelete = async (item: T) => {
-    if (!window.confirm(`Delete this ${title.slice(0, -1).toLowerCase()}?`)) return;
+    const normalizedEntityLabel = entityLabel ?? title.slice(0, -1);
+    if (!window.confirm(removeConfirmMessage ?? `${removeActionLabel} this ${normalizedEntityLabel.toLowerCase()}?`)) return;
     try {
       await remove.mutateAsync(item.id);
-      toast({ title: `${title.slice(0, -1)} deleted` });
+      toast({ title: removeSuccessMessage ?? `${normalizedEntityLabel} ${removeActionLabel.toLowerCase()}ed` });
     } catch {
-      toast({ title: 'Delete failed', description: 'This record may still be referenced.', variant: 'destructive' });
+      toast({ title: `${removeActionLabel} failed`, description: 'This record may still be referenced.', variant: 'destructive' });
     }
   };
 
@@ -294,13 +312,15 @@ function FleetCrudPage<T extends { id: string }>({
                 ))}
                 <TableCell>
                   <div className="flex justify-end gap-1">
-                    <Button variant="ghost" size="icon" onClick={() => setViewing(item)} title="View">
+                    {!hideViewAction ? (
-                      <Eye className="size-4" />
+                      <Button variant="ghost" size="icon" onClick={() => setViewing(item)} title="View">
-                    </Button>
+                        <Eye className="size-4" />
+                      </Button>
+                    ) : null}
                     <Button variant="ghost" size="icon" onClick={() => openEdit(item)} title="Edit">
                       <Edit className="size-4" />
                     </Button>
-                    <Button variant="ghost" size="icon" onClick={() => handleDelete(item)} title="Delete">
+                    <Button variant="ghost" size="icon" onClick={() => handleDelete(item)} title={removeActionLabel}>
                       <Trash2 className="size-4" />
                     </Button>
                   </div>
@@ -631,3 +651,82 @@ export function CargoesCrudPage() {
     />
   );
 }
+
+export function LocomotivesCrudPage() {
+  const query = useLocomotives();
+
+  return (
+    <FleetCrudPage<Locomotive>
+      title="Locomotives"
+      entityLabel="Locomotive"
+      description="Manage locomotive master data used by train scheduling and fleet operations."
+      addLabel="Add Locomotive"
+      data={query.data}
+      isLoading={query.isLoading}
+      create={useCreateLocomotive()}
+      update={useUpdateLocomotive()}
+      remove={useDecommissionLocomotive()}
+      removeActionLabel="Decommission"
+      removeConfirmMessage="Decommission this locomotive?"
+      removeSuccessMessage="Locomotive decommissioned"
+      searchText={(locomotive) =>
+        [
+          locomotive.code,
+          locomotive.name,
+          locomotive.locomotiveType,
+          locomotive.status,
+        ].join(' ')
+      }
+      columns={[
+        { key: 'code', label: 'Code' },
+        { key: 'name', label: 'Name', render: (locomotive) => locomotive.name || '-' },
+        { key: 'locomotiveType', label: 'Type' },
+        { key: 'status', label: 'Status', render: (locomotive) => statusBadge(locomotive.status) },
+        { key: 'maxPullWeightTons', label: 'Max pull (tons)' },
+        { key: 'maxTrainLengthMeters', label: 'Max length (m)' },
+      ]}
+      fields={[
+        { key: 'code', label: 'Code', required: true },
+        { key: 'name', label: 'Name' },
+        {
+          key: 'locomotiveType',
+          label: 'Locomotive type',
+          type: 'select',
+          required: true,
+          options: [
+            { value: 'DIESEL', label: 'Diesel' },
+            { value: 'ELECTRIC', label: 'Electric' },
+          ],
+        },
+        {
+          key: 'status',
+          label: 'Status',
+          type: 'select',
+          required: true,
+          options: [
+            { value: 'AVAILABLE', label: 'Available' },
+            { value: 'MAINTENANCE', label: 'Maintenance' },
+            { value: 'ASSIGNED', label: 'Assigned' },
+            { value: 'OUT_OF_SERVICE', label: 'Out of service' },
+          ],
+        },
+        { key: 'maxPullWeightTons', label: 'Max pulling weight (tons)', type: 'number', required: true },
+        { key: 'maxTrainLengthMeters', label: 'Max train length (meters)', type: 'number', required: true },
+        { key: 'powerKw', label: 'Power (kW)', type: 'number' },
+        { key: 'tractionForceKn', label: 'Traction force (kN)', type: 'number' },
+        { key: 'maxSpeedKmh', label: 'Max speed (km/h)', type: 'number' },
+      ]}
+      emptyValues={{
+        code: '',
+        name: '',
+        locomotiveType: 'DIESEL',
+        status: 'AVAILABLE',
+        maxPullWeightTons: 0,
+        maxTrainLengthMeters: 760,
+        powerKw: '',
+        tractionForceKn: '',
+        maxSpeedKmh: '',
+      }}
+    />
+  );
+}

apps/edr-freight-web/backoffice/src/pages/fleet/RoutesPage.tsx

@@ -0,0 +1,379 @@
+import { FormEvent, useMemo, useState } from 'react';
+import { Edit, Eye, Plus, Search, Trash2 } from 'lucide-react';
+
+import { Button } from '@/components/ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { useCreateRoute, useDeactivateRoute, useRouteYards, useRoutes, useUpdateRoute } from '@/hooks/useRoutes';
+import { useToast } from '@/hooks/use-toast';
+import type { RouteRecord, YardRef } from '@/services/routes.service';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@edr/ui-common';
+
+type RouteFormState = {
+  name: string;
+  milestones: string[];
+};
+
+const emptyForm = (): RouteFormState => ({ name: '', milestones: ['', ''] });
+
+const yardLabel = (yard?: YardRef | null) => (yard ? `${yard.label} (${yard.code})` : '-');
+
+const routeStops = (route: RouteRecord) =>
+  (route.milestones ?? [])
+    .sort((left, right) => left.sequenceNo - right.sequenceNo)
+    .map((milestone) => milestone.yard?.label ?? milestone.yard?.code ?? milestone.yardId);
+
+const normalizeRouteError = (error: unknown) => {
+  const responseData = (error as { response?: { data?: unknown } })?.response?.data;
+  const data = responseData && typeof responseData === 'object' ? (responseData as Record<string, unknown>) : undefined;
+  const rawMessage = data?.message ?? data?.error ?? (error as Error)?.message;
+
+  return Array.isArray(rawMessage)
+    ? rawMessage.join(', ')
+    : rawMessage
+      ? String(rawMessage)
+      : 'Save failed';
+};
+
+export default function RoutesPage() {
+  const [search, setSearch] = useState('');
+  const [formOpen, setFormOpen] = useState(false);
+  const [viewing, setViewing] = useState<RouteRecord | null>(null);
+  const [editing, setEditing] = useState<RouteRecord | null>(null);
+  const [form, setForm] = useState<RouteFormState>(emptyForm());
+  const { toast } = useToast();
+
+  const routesQuery = useRoutes();
+  const yardsQuery = useRouteYards();
+  const createMutation = useCreateRoute();
+  const updateMutation = useUpdateRoute();
+  const deactivateMutation = useDeactivateRoute();
+
+  const filteredRoutes = useMemo(() => {
+    const query = search.trim().toLowerCase();
+    if (!query) return routesQuery.data ?? [];
+
+    return (routesQuery.data ?? []).filter((route) => {
+      const searchable = [
+        route.name,
+        route.originYard?.label,
+        route.originYard?.code,
+        route.destinationYard?.label,
+        route.destinationYard?.code,
+        ...routeStops(route),
+      ]
+        .filter(Boolean)
+        .join(' ')
+        .toLowerCase();
+
+      return searchable.includes(query);
+    });
+  }, [routesQuery.data, search]);
+
+  const yardOptions = useMemo(
+    () =>
+      (yardsQuery.data ?? []).map((yard) => ({
+        value: yard.id,
+        label: `${yard.label} (${yard.code})`,
+      })),
+    [yardsQuery.data],
+  );
+
+  const resetForm = () => {
+    setFormOpen(false);
+    setEditing(null);
+    setForm(emptyForm());
+  };
+
+  const openCreate = () => {
+    setEditing(null);
+    setForm(emptyForm());
+    setFormOpen(true);
+  };
+
+  const openEdit = (route: RouteRecord) => {
+    setEditing(route);
+    setForm({
+      name: route.name,
+      milestones: (route.milestones ?? [])
+        .sort((left, right) => left.sequenceNo - right.sequenceNo)
+        .map((milestone) => milestone.yardId),
+    });
+    setFormOpen(true);
+  };
+
+  const setMilestone = (index: number, yardId: string) => {
+    setForm((current) => ({
+      ...current,
+      milestones: current.milestones.map((value, currentIndex) =>
+        currentIndex === index ? yardId : value,
+      ),
+    }));
+  };
+
+  const addMilestone = () => {
+    setForm((current) => ({ ...current, milestones: [...current.milestones, ''] }));
+  };
+
+  const removeMilestone = (index: number) => {
+    setForm((current) => ({
+      ...current,
+      milestones: current.milestones.filter((_, currentIndex) => currentIndex !== index),
+    }));
+  };
+
+  const handleSubmit = async (event: FormEvent) => {
+    event.preventDefault();
+
+    if (!form.name.trim()) {
+      toast({ title: 'Save failed', description: 'Route name is required', variant: 'destructive' });
+      return;
+    }
+
+    if (form.milestones.length < 2 || form.milestones.some((yardId) => !yardId)) {
+      toast({
+        title: 'Save failed',
+        description: 'Select at least an origin and destination yard',
+        variant: 'destructive',
+      });
+      return;
+    }
+
+    try {
+      const payload = {
+        name: form.name.trim(),
+        milestones: form.milestones.map((yardId) => ({ yardId })),
+        isActive: editing?.isActive ?? true,
+      };
+
+      if (editing) {
+        await updateMutation.mutateAsync({ id: editing.id, data: payload });
+        toast({ title: 'Route updated' });
+      } else {
+        await createMutation.mutateAsync(payload);
+        toast({ title: 'Route created' });
+      }
+
+      resetForm();
+    } catch (error) {
+      toast({ title: 'Save failed', description: normalizeRouteError(error), variant: 'destructive' });
+    }
+  };
+
+  const handleDeactivate = async (route: RouteRecord) => {
+    if (!window.confirm('Deactivate this route?')) return;
+
+    try {
+      await deactivateMutation.mutateAsync(route.id);
+      toast({ title: 'Route deactivated' });
+    } catch {
+      toast({ title: 'Deactivate failed', description: 'Could not deactivate route', variant: 'destructive' });
+    }
+  };
+
+  const isSaving = createMutation.isPending || updateMutation.isPending;
+
+  const availableOptionsForIndex = (index: number) => {
+    const selectedByOthers = new Set(
+      form.milestones.filter((value, currentIndex) => currentIndex !== index && value),
+    );
+
+    return yardOptions.filter(
+      (option) => option.value === form.milestones[index] || !selectedByOthers.has(option.value),
+    );
+  };
+
+  return (
+    <div className="space-y-5 p-6">
+      <div className="flex flex-col gap-4 sm:flex-row sm:items-end sm:justify-between">
+        <div>
+          <h1 className="text-2xl font-semibold tracking-tight">Routes</h1>
+          <p className="mt-1 text-sm text-muted-foreground">
+            Build train routes from an ordered yard list where the first stop is the origin and the last stop is the destination.
+          </p>
+        </div>
+        <Button onClick={openCreate}>
+          <Plus className="size-4" />
+          Add Route
+        </Button>
+      </div>
+
+      <div className="flex max-w-md items-center gap-2 rounded-md border bg-background px-3">
+        <Search className="size-4 text-muted-foreground" />
+        <Input
+          className="border-0 px-0 shadow-none focus-visible:ring-0"
+          placeholder="Search routes"
+          value={search}
+          onChange={(event) => setSearch(event.target.value)}
+        />
+      </div>
+
+      <div className="overflow-hidden rounded-lg border bg-card">
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Name</TableHead>
+              <TableHead>Origin</TableHead>
+              <TableHead>Destination</TableHead>
+              <TableHead>Milestones</TableHead>
+              <TableHead>Status</TableHead>
+              <TableHead className="w-[150px] text-right">Actions</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {filteredRoutes.map((route) => (
+              <TableRow key={route.id}>
+                <TableCell>{route.name}</TableCell>
+                <TableCell>{yardLabel(route.originYard)}</TableCell>
+                <TableCell>{yardLabel(route.destinationYard)}</TableCell>
+                <TableCell>{Math.max((route.milestones?.length ?? 0) - 2, 0)}</TableCell>
+                <TableCell>{route.isActive ? 'Active' : 'Inactive'}</TableCell>
+                <TableCell>
+                  <div className="flex justify-end gap-1">
+                    <Button variant="ghost" size="icon" onClick={() => setViewing(route)} title="View">
+                      <Eye className="size-4" />
+                    </Button>
+                    <Button variant="ghost" size="icon" onClick={() => openEdit(route)} title="Edit">
+                      <Edit className="size-4" />
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="icon"
+                      onClick={() => handleDeactivate(route)}
+                      title="Deactivate"
+                      disabled={!route.isActive || deactivateMutation.isPending}
+                    >
+                      <Trash2 className="size-4" />
+                    </Button>
+                  </div>
+                </TableCell>
+              </TableRow>
+            ))}
+            {!routesQuery.isLoading && filteredRoutes.length === 0 ? (
+              <TableRow>
+                <TableCell colSpan={6} className="h-28 text-center text-muted-foreground">
+                  No routes found.
+                </TableCell>
+              </TableRow>
+            ) : null}
+            {routesQuery.isLoading ? (
+              <TableRow>
+                <TableCell colSpan={6} className="h-28 text-center text-muted-foreground">
+                  Loading...
+                </TableCell>
+              </TableRow>
+            ) : null}
+          </TableBody>
+        </Table>
+      </div>
+
+      <Dialog open={formOpen} onOpenChange={(open) => (!open ? resetForm() : setFormOpen(true))}>
+        <DialogContent className="max-h-[90vh] overflow-y-auto">
+          <DialogHeader>
+            <DialogTitle>{editing ? 'Edit Route' : 'Add Route'}</DialogTitle>
+          </DialogHeader>
+          <form className="space-y-4" onSubmit={handleSubmit}>
+            <div className="space-y-2">
+              <Label htmlFor="route-name">Name</Label>
+              <Input
+                id="route-name"
+                value={form.name}
+                onChange={(event) => setForm((current) => ({ ...current, name: event.target.value }))}
+              />
+            </div>
+
+            <div className="space-y-3">
+              <div className="flex items-center justify-between">
+                <Label>Stops</Label>
+                <Button type="button" variant="outline" size="sm" onClick={addMilestone}>
+                  <Plus className="size-4" />
+                  Add next milestone
+                </Button>
+              </div>
+              {form.milestones.map((yardId, index) => {
+                const role = index === 0 ? 'Origin' : index === form.milestones.length - 1 ? 'Destination' : 'Milestone';
+                const availableOptions = availableOptionsForIndex(index);
+                return (
+                  <div key={`${role}-${index}`} className="grid gap-2 rounded-lg border p-3 sm:grid-cols-[120px,1fr,auto] sm:items-center">
+                    <p className="text-sm font-medium">{role}</p>
+                    <Select value={yardId} onValueChange={(value) => setMilestone(index, value)}>
+                      <SelectTrigger>
+                        <SelectValue placeholder="Select yard" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {availableOptions.map((option) => (
+                          <SelectItem key={option.value} value={option.value}>
+                            {option.label}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                    <Button
+                      type="button"
+                      variant="ghost"
+                      size="icon"
+                      onClick={() => removeMilestone(index)}
+                      disabled={form.milestones.length <= 2}
+                      title="Remove stop"
+                    >
+                      <Trash2 className="size-4" />
+                    </Button>
+                  </div>
+                );
+              })}
+            </div>
+
+            <DialogFooter>
+              <Button type="button" variant="outline" onClick={resetForm}>
+                Cancel
+              </Button>
+              <Button type="submit" disabled={isSaving}>
+                Save
+              </Button>
+            </DialogFooter>
+          </form>
+        </DialogContent>
+      </Dialog>
+
+      <Dialog open={Boolean(viewing)} onOpenChange={(open) => (!open ? setViewing(null) : null)}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>Route details</DialogTitle>
+          </DialogHeader>
+          {viewing ? (
+            <div className="space-y-3 text-sm">
+              <div>
+                <p className="font-medium">Name</p>
+                <p className="text-muted-foreground">{viewing.name}</p>
+              </div>
+              <div>
+                <p className="font-medium">Status</p>
+                <p className="text-muted-foreground">{viewing.isActive ? 'Active' : 'Inactive'}</p>
+              </div>
+              <div>
+                <p className="font-medium">Stops</p>
+                <div className="mt-2 space-y-2">
+                  {routeStops(viewing).map((stop, index, stops) => (
+                    <div key={`${stop}-${index}`} className="rounded-md border px-3 py-2 text-muted-foreground">
+                      {index === 0 ? 'Origin' : index === stops.length - 1 ? 'Destination' : `Milestone ${index}`}:
+                      {' '}
+                      {stop}
+                    </div>
+                  ))}
+                </div>
+              </div>
+            </div>
+          ) : null}
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}

apps/edr-freight-web/backoffice/src/pages/trains/TrainsPage.tsx

@@ -19,13 +19,8 @@ import {
 
 import Breadcrumbs from '@/components/ui/Breadcrumbs';
 import { QUERY_KEYS } from '@/constants/QUERY_KEYS';
+import { useRoutes } from '@/hooks/useRoutes';
 import { trainSchedulingService } from '@/services/trainScheduling.service';
-import type {
-  EligibleContainerBooking,
-  TrainScheduleFilters,
-  TrainSchedulePreviewResponse,
-  YardOption,
-} from '@/types/trainScheduling';
 
 const inputClassName =
   'w-full rounded-xl border border-border bg-background px-3 py-2.5 text-sm text-foreground outline-none transition focus:border-emerald-500 focus:ring-2 focus:ring-emerald-100 dark:focus:ring-emerald-950';
@@ -43,11 +38,6 @@ const formatDate = (value?: string | null) => {
   }).format(date);
 };
 
-const formatDayInput = (value?: string | null) => {
-  if (!value) return '';
-  return value.slice(0, 10);
-};
-
 const parseError = (error: unknown, fallback: string) => {
   if (isAxiosError(error)) {
     const message = error.response?.data?.message;
@@ -59,62 +49,39 @@ const parseError = (error: unknown, fallback: string) => {
   return fallback;
 };
 
-const deriveFromBooking = (
-  booking: EligibleContainerBooking | undefined,
-  stations: YardOption[],
-) => {
-  if (!booking) {
-    return { originStationId: '', destinationStationId: '', scheduleDate: '' };
-  }
-
-  const originStationId = stations.find((station) => station.name === booking.origin)?.id ?? '';
-  const destinationStationId =
-    stations.find((station) => station.name === booking.destination)?.id ?? '';
-
-  return {
-    originStationId,
-    destinationStationId,
-    scheduleDate: formatDayInput(booking.preferredDepartureDate),
-  };
-};
-
 const TrainsPage = () => {
   const qc = useQueryClient();
-  const [filters, setFilters] = useState<TrainScheduleFilters>({});
+  const [routeId, setRouteId] = useState('');
-  const [selectedBookingIds, setSelectedBookingIds] = useState<string[]>([]);
+  const [scheduleDate, setScheduleDate] = useState('');
-  const [preview, setPreview] = useState<TrainSchedulePreviewResponse | null>(null);
   const [selectedLocomotiveId, setSelectedLocomotiveId] = useState('');
   const [detailId, setDetailId] = useState<string | null>(null);
   const [scheduleSearch, setScheduleSearch] = useState('');
   const [scheduleStatusFilter, setScheduleStatusFilter] = useState('ALL');
 
-  const stationsQuery = useQuery({
+  const routesQuery = useRoutes();
-    queryKey: QUERY_KEYS.TRAIN_SCHEDULING.stations(),
-    queryFn: () => trainSchedulingService.getStations(),
-  });
-
-  const eligibleQuery = useQuery({
-    queryKey: QUERY_KEYS.TRAIN_SCHEDULING.eligible(filters),
-    queryFn: () => trainSchedulingService.getEligibleBookings(filters),
-  });
-
   const locomotivesQuery = useQuery({
     queryKey: QUERY_KEYS.TRAIN_SCHEDULING.locomotives(),
     queryFn: () => trainSchedulingService.getAvailableLocomotives(),
   });
-
   const schedulesQuery = useQuery({
     queryKey: QUERY_KEYS.TRAIN_SCHEDULING.schedules(),
     queryFn: () => trainSchedulingService.listSchedules(),
   });
-
   const detailQuery = useQuery({
     queryKey: QUERY_KEYS.TRAIN_SCHEDULING.scheduleById(detailId ?? ''),
     queryFn: () => trainSchedulingService.getScheduleById(detailId!),
     enabled: Boolean(detailId),
   });
 
-  const eligibleItems = eligibleQuery.data?.items ?? [];
+  const activeRoutes = useMemo(
+    () => (routesQuery.data ?? []).filter((route) => route.isActive),
+    [routesQuery.data],
+  );
+  const selectedRoute = activeRoutes.find((route) => route.id === routeId) ?? null;
+  const selectedLocomotive = (locomotivesQuery.data ?? []).find(
+    (locomotive) => locomotive.id === selectedLocomotiveId,
+  );
+
   const filteredSchedules = useMemo(() => {
     const query = scheduleSearch.trim().toLowerCase();
 
@@ -132,6 +99,7 @@ const TrainsPage = () => {
 
       const haystack = [
         schedule.id,
+        schedule.routeName ?? '',
         schedule.origin ?? '',
         schedule.destination ?? '',
         schedule.locomotive?.code ?? '',
@@ -143,70 +111,24 @@ const TrainsPage = () => {
       return haystack.includes(query);
     });
   }, [scheduleSearch, scheduleStatusFilter, schedulesQuery.data]);
-  const selectedBookings = useMemo(
-    () => eligibleItems.filter((booking) => selectedBookingIds.includes(booking.id)),
-    [eligibleItems, selectedBookingIds],
-  );
-
-  const summary = useMemo(() => {
-    const totalWeightTons = selectedBookings.reduce((sum, booking) => sum + booking.weightTons, 0);
-    const wagonsNeeded = Math.ceil(totalWeightTons / 70);
-    const totalLengthMeters = wagonsNeeded * 14;
-    const routeSet = new Set(selectedBookings.map((booking) => `${booking.origin} -> ${booking.destination}`));
-    const dateSet = new Set(selectedBookings.map((booking) => formatDayInput(booking.preferredDepartureDate)));
-
-    return {
-      count: selectedBookings.length,
-      totalWeightTons,
-      wagonsNeeded: Number.isFinite(wagonsNeeded) ? wagonsNeeded : 0,
-      totalLengthMeters: Number.isFinite(totalLengthMeters) ? totalLengthMeters : 0,
-      route: routeSet.size === 1 ? [...routeSet][0] : selectedBookings.length ? 'Mixed route' : '-',
-      scheduleDate: dateSet.size === 1 ? [...dateSet][0] : selectedBookings.length ? 'Mixed date' : '-',
-    };
-  }, [selectedBookings]);
-
-  const previewMutation = useMutation({
-    mutationFn: () => {
-      if (!filters.originStationId || !filters.destinationStationId || !filters.scheduleDate) {
-        throw new Error('Please select origin, destination, and schedule date');
-      }
-      return trainSchedulingService.preview({
-        bookingIds: selectedBookingIds,
-        scheduleDate: new Date(`${filters.scheduleDate}T08:00:00.000Z`).toISOString(),
-        originStationId: filters.originStationId,
-        destinationStationId: filters.destinationStationId,
-      });
-    },
-    onSuccess: (data) => {
-      setPreview(data);
-      toast.success(data.valid ? 'Preview generated' : 'Preview has validation issues');
-    },
-    onError: (error) => {
-      toast.error(parseError(error, 'Failed to preview train schedule'));
-    },
-  });
 
   const createMutation = useMutation({
     mutationFn: () => {
-      if (!selectedLocomotiveId) {
+      if (!routeId || !scheduleDate || !selectedLocomotiveId) {
-        throw new Error('Please select a locomotive');
+        throw new Error('Please select route, departure date, and locomotive');
-      }
-      if (!filters.originStationId || !filters.destinationStationId || !filters.scheduleDate) {
-        throw new Error('Please select origin, destination, and schedule date');
       }
+
       return trainSchedulingService.createSchedule({
-        bookingIds: selectedBookingIds,
+        routeId,
-        scheduleDate: new Date(`${filters.scheduleDate}T08:00:00.000Z`).toISOString(),
+        scheduleDate: new Date(`${scheduleDate}T08:00:00.000Z`).toISOString(),
-        originStationId: filters.originStationId,
-        destinationStationId: filters.destinationStationId,
         locomotiveId: selectedLocomotiveId,
       });
     },
     onSuccess: (data) => {
       toast.success('Train schedule created');
-      setSelectedBookingIds([]);
+      setRouteId('');
+      setScheduleDate('');
       setSelectedLocomotiveId('');
-      setPreview(null);
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.TRAIN_SCHEDULING.ROOT });
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.TRAIN_SCHEDULING.schedules() });
       void qc.invalidateQueries({ queryKey: QUERY_KEYS.TRAIN_SCHEDULING.locomotives() });
@@ -232,32 +154,12 @@ const TrainsPage = () => {
     },
   });
 
-  const toggleBooking = (booking: EligibleContainerBooking, checked: boolean) => {
-    setSelectedBookingIds((current) => {
-      if (checked) {
-        const next = [...new Set([...current, booking.id])];
-        if (next.length === 1) {
-          const defaults = deriveFromBooking(booking, stationsQuery.data ?? []);
-          setFilters((prev) => ({
-            ...prev,
-            originStationId: prev.originStationId || defaults.originStationId,
-            destinationStationId: prev.destinationStationId || defaults.destinationStationId,
-            scheduleDate: prev.scheduleDate || defaults.scheduleDate,
-          }));
-        }
-        return next;
-      }
-      return current.filter((id) => id !== booking.id);
-    });
-    setPreview(null);
-  };
-
   const detail = detailQuery.data;
-  const isBusy = previewMutation.isPending || createMutation.isPending;
+  const isBusy = createMutation.isPending;
 
   return (
     <div className="space-y-6 p-6">
-      <Breadcrumbs items={[{ label: 'Operations' }, { label: 'Train scheduling' }]} />
+      <Breadcrumbs items={[{ label: 'Operations' }, { label: 'Train schedules' }]} />
 
       <section className="overflow-hidden rounded-3xl border border-border bg-card shadow-sm">
         <div className="flex flex-col gap-5 border-b border-border px-6 py-6 lg:flex-row lg:items-center lg:justify-between">
@@ -266,9 +168,9 @@ const TrainsPage = () => {
               <TrainTrack className="size-7" />
             </div>
             <div>
-              <h1 className="text-2xl font-bold tracking-tight">Train Scheduling</h1>
+              <h1 className="text-2xl font-bold tracking-tight">Train Schedules</h1>
               <p className="mt-1 text-sm text-muted-foreground">
-                Build container train schedules from compatible bookings, preview wagon plans, and assign locomotives.
+                Create the train schedule first, reserve the locomotive, and assign bookings and wagons later.
               </p>
             </div>
           </div>
@@ -276,7 +178,7 @@ const TrainsPage = () => {
             variant="outline"
             className="gap-2"
             onClick={() => {
-              void eligibleQuery.refetch();
+              void routesQuery.refetch();
               void schedulesQuery.refetch();
               void locomotivesQuery.refetch();
             }}
@@ -286,346 +188,185 @@ const TrainsPage = () => {
           </Button>
         </div>
 
-        <div className="grid gap-6 p-6 xl:grid-cols-[1.8fr,1fr]">
+        <div className="grid gap-6 p-6 xl:grid-cols-[1.1fr,1.4fr]">
-          <div className="space-y-6">
+          <section className="rounded-2xl border border-border bg-background/60 p-5">
-            <section className="rounded-2xl border border-border bg-background/60 p-5">
+            <div className="mb-4 flex items-center gap-2">
-              <div className="mb-4 flex items-center gap-2">
+              <Calendar className="size-4 text-muted-foreground" />
-                <Calendar className="size-4 text-muted-foreground" />
-                <h2 className="text-sm font-semibold uppercase tracking-wide text-muted-foreground">
-                  Filters
-                </h2>
-              </div>
-              <div className="grid gap-4 md:grid-cols-2 xl:grid-cols-4">
-                <div className="space-y-2">
-                  <label className="text-sm font-medium">Origin station</label>
-                  <Select
-                    value={filters.originStationId ?? ''}
-                    onValueChange={(value) =>
-                      setFilters((current) => ({
-                        ...current,
-                        originStationId: value === '__all__' ? undefined : value,
-                      }))
-                    }
-                  >
-                    <SelectTrigger>
-                      <SelectValue placeholder="All origins" />
-                    </SelectTrigger>
-                    <SelectContent>
-                      <SelectItem value="__all__">All origins</SelectItem>
-                      {(stationsQuery.data ?? []).map((station) => (
-                        <SelectItem key={station.id} value={station.id}>
-                          {station.name}
-                        </SelectItem>
-                      ))}
-                    </SelectContent>
-                  </Select>
-                </div>
-                <div className="space-y-2">
-                  <label className="text-sm font-medium">Destination station</label>
-                  <Select
-                    value={filters.destinationStationId ?? ''}
-                    onValueChange={(value) =>
-                      setFilters((current) => ({
-                        ...current,
-                        destinationStationId: value === '__all__' ? undefined : value,
-                      }))
-                    }
-                  >
-                    <SelectTrigger>
-                      <SelectValue placeholder="All destinations" />
-                    </SelectTrigger>
-                    <SelectContent>
-                      <SelectItem value="__all__">All destinations</SelectItem>
-                      {(stationsQuery.data ?? []).map((station) => (
-                        <SelectItem key={station.id} value={station.id}>
-                          {station.name}
-                        </SelectItem>
-                      ))}
-                    </SelectContent>
-                  </Select>
-                </div>
-                <div className="space-y-2">
-                  <label className="text-sm font-medium">Schedule date</label>
-                  <input
-                    className={inputClassName}
-                    type="date"
-                    value={filters.scheduleDate ?? ''}
-                    onChange={(event) =>
-                      setFilters((current) => ({
-                        ...current,
-                        scheduleDate: event.target.value || undefined,
-                      }))
-                    }
-                  />
-                </div>
-              </div>
-            </section>
-
-            <section className="rounded-2xl border border-border bg-background/60 p-5">
-              <div className="mb-4 flex items-center justify-between">
-                <div>
-                  <h2 className="text-lg font-semibold">Eligible container bookings</h2>
-                  <p className="text-sm text-muted-foreground">
-                    Only paid container bookings not already assigned to a schedule appear here.
-                  </p>
-                </div>
-                <span className="rounded-full bg-muted px-3 py-1 text-xs font-medium text-muted-foreground">
-                  {eligibleQuery.data?.count ?? 0} bookings
-                </span>
-              </div>
-
-              <div className="overflow-x-auto rounded-2xl border border-border">
-                <table className="min-w-full divide-y divide-border text-sm">
-                  <thead className="bg-muted/40 text-left text-xs uppercase tracking-wide text-muted-foreground">
-                    <tr>
-                      <th className="px-3 py-3">Select</th>
-                      <th className="px-3 py-3">Booking</th>
-                      <th className="px-3 py-3">Customer</th>
-                      <th className="px-3 py-3">Container</th>
-                      <th className="px-3 py-3">Qty</th>
-                      <th className="px-3 py-3">Weight</th>
-                      <th className="px-3 py-3">Origin</th>
-                      <th className="px-3 py-3">Destination</th>
-                      <th className="px-3 py-3">Departure</th>
-                      <th className="px-3 py-3">Status</th>
-                    </tr>
-                  </thead>
-                  <tbody className="divide-y divide-border bg-card">
-                    {eligibleItems.map((booking) => (
-                      <tr key={booking.id} className="hover:bg-muted/20">
-                        <td className="px-3 py-3">
-                          <input
-                            type="checkbox"
-                            checked={selectedBookingIds.includes(booking.id)}
-                            onChange={(event) => toggleBooking(booking, event.target.checked)}
-                          />
-                        </td>
-                        <td className="px-3 py-3 font-medium">{booking.reference}</td>
-                        <td className="px-3 py-3">{booking.customer}</td>
-                        <td className="px-3 py-3">{booking.containerType}</td>
-                        <td className="px-3 py-3">{booking.quantity}</td>
-                        <td className="px-3 py-3">{booking.weightTons.toLocaleString()} T</td>
-                        <td className="px-3 py-3">{booking.origin}</td>
-                        <td className="px-3 py-3">{booking.destination}</td>
-                        <td className="px-3 py-3">{formatDate(booking.preferredDepartureDate)}</td>
-                        <td className="px-3 py-3">{booking.status}</td>
-                      </tr>
-                    ))}
-                    {!eligibleQuery.isLoading && eligibleItems.length === 0 ? (
-                      <tr>
-                        <td className="px-3 py-8 text-center text-sm text-muted-foreground" colSpan={10}>
-                          No eligible container bookings matched the current filters.
-                        </td>
-                      </tr>
-                    ) : null}
-                  </tbody>
-                </table>
-              </div>
-            </section>
-          </div>
-
-          <div className="space-y-6">
-            <section className="rounded-2xl border border-border bg-background/60 p-5">
               <h2 className="text-lg font-semibold">Schedule builder</h2>
-              <div className="mt-4 grid gap-3 sm:grid-cols-2 xl:grid-cols-1">
+            </div>
-                <div className="rounded-xl border border-border bg-card p-4">
-                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Selected bookings</p>
-                  <p className="mt-2 text-2xl font-semibold">{summary.count}</p>
-                </div>
-                <div className="rounded-xl border border-border bg-card p-4">
-                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Total weight</p>
-                  <p className="mt-2 text-2xl font-semibold">{summary.totalWeightTons.toLocaleString()} T</p>
-                </div>
-                <div className="rounded-xl border border-border bg-card p-4">
-                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Route</p>
-                  <p className="mt-2 text-sm font-medium">{summary.route}</p>
-                </div>
-                <div className="rounded-xl border border-border bg-card p-4">
-                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Schedule date</p>
-                  <p className="mt-2 text-sm font-medium">{summary.scheduleDate}</p>
-                </div>
-                <div className="rounded-xl border border-border bg-card p-4">
-                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Estimated wagon type</p>
-                  <p className="mt-2 text-sm font-medium">NW5</p>
-                </div>
-                <div className="rounded-xl border border-border bg-card p-4">
-                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Estimated wagons / length</p>
-                  <p className="mt-2 text-sm font-medium">
-                    {summary.wagonsNeeded} wagons / {summary.totalLengthMeters} m
-                  </p>
-                </div>
-              </div>
 
-              <div className="mt-5 flex flex-col gap-3">
+            <div className="grid gap-4">
-                <Button
+              <div className="space-y-2">
-                  className="w-full"
+                <label className="text-sm font-medium">Route</label>
-                  disabled={!selectedBookingIds.length || isBusy}
+                <Select value={routeId} onValueChange={setRouteId}>
-                  onClick={() => previewMutation.mutate()}
-                >
-                  Preview schedule
-                </Button>
-
-                <div className="space-y-2">
-                  <label className="text-sm font-medium">Locomotive</label>
-                  <Select value={selectedLocomotiveId} onValueChange={setSelectedLocomotiveId}>
-                    <SelectTrigger>
-                      <SelectValue placeholder="Select available locomotive" />
-                    </SelectTrigger>
-                    <SelectContent>
-                      {(locomotivesQuery.data ?? []).map((locomotive) => (
-                        <SelectItem key={locomotive.id} value={locomotive.id}>
-                          {locomotive.code} - {locomotive.maxPullWeightTons}T
-                        </SelectItem>
-                      ))}
-                    </SelectContent>
-                  </Select>
-                </div>
-
-                <Button
-                  className="w-full"
-                  disabled={!preview?.valid || !selectedLocomotiveId || isBusy}
-                  onClick={() => createMutation.mutate()}
-                >
-                  Create schedule
-                </Button>
-              </div>
-
-              {preview ? (
-                <div className="mt-5 space-y-4 rounded-2xl border border-border bg-card p-4">
-                  <div className="flex items-center justify-between">
-                    <h3 className="font-semibold">Preview result</h3>
-                    <span
-                      className={`rounded-full px-3 py-1 text-xs font-medium ${
-                        preview.valid
-                          ? 'bg-emerald-100 text-emerald-700 dark:bg-emerald-950 dark:text-emerald-300'
-                          : 'bg-rose-100 text-rose-700 dark:bg-rose-950 dark:text-rose-300'
-                      }`}
-                    >
-                      {preview.valid ? 'Valid' : 'Invalid'}
-                    </span>
-                  </div>
-
-                  <div className="grid gap-3 sm:grid-cols-3">
-                    <div className="rounded-xl border border-border p-3">
-                      <p className="text-xs uppercase tracking-wide text-muted-foreground">Wagons</p>
-                      <p className="mt-1 font-semibold">{preview.summary.wagonsNeeded}</p>
-                    </div>
-                    <div className="rounded-xl border border-border p-3">
-                      <p className="text-xs uppercase tracking-wide text-muted-foreground">Weight</p>
-                      <p className="mt-1 font-semibold">{preview.summary.totalWeightTons} T</p>
-                    </div>
-                    <div className="rounded-xl border border-border p-3">
-                      <p className="text-xs uppercase tracking-wide text-muted-foreground">Length</p>
-                      <p className="mt-1 font-semibold">{preview.summary.totalLengthMeters} m</p>
-                    </div>
-                  </div>
-
-                  {preview.violations.length > 0 ? (
-                    <div className="rounded-xl border border-rose-200 bg-rose-50 p-3 text-sm text-rose-700 dark:border-rose-950 dark:bg-rose-950/30 dark:text-rose-300">
-                      <ul className="list-disc space-y-1 pl-5">
-                        {preview.violations.map((violation) => (
-                          <li key={violation}>{violation}</li>
-                        ))}
-                      </ul>
-                    </div>
-                  ) : null}
-                </div>
-              ) : null}
-            </section>
-
-            <section className="rounded-2xl border border-border bg-background/60 p-5">
-              <div className="mb-4 flex items-center justify-between">
-                <div>
-                  <h2 className="text-lg font-semibold">Created schedules</h2>
-                  <p className="text-sm text-muted-foreground">Open a schedule to inspect wagons and allocations.</p>
-                </div>
-                <span className="rounded-full bg-muted px-3 py-1 text-xs font-medium text-muted-foreground">
-                  {filteredSchedules.length} schedules
-                </span>
-              </div>
-
-              <div className="mb-4 grid gap-3 md:grid-cols-[1fr,220px]">
-                <input
-                  className={inputClassName}
-                  placeholder="Search by schedule, route, locomotive, or status"
-                  value={scheduleSearch}
-                  onChange={(event) => setScheduleSearch(event.target.value)}
-                />
-                <Select value={scheduleStatusFilter} onValueChange={setScheduleStatusFilter}>
                   <SelectTrigger>
-                    <SelectValue placeholder="All statuses" />
+                    <SelectValue placeholder="Select active route" />
                   </SelectTrigger>
                   <SelectContent>
-                    <SelectItem value="ALL">All statuses</SelectItem>
+                    {activeRoutes.map((route) => (
-                    <SelectItem value="DRAFT">DRAFT</SelectItem>
+                      <SelectItem key={route.id} value={route.id}>
-                    <SelectItem value="SCHEDULED">SCHEDULED</SelectItem>
+                        {route.name}
-                    <SelectItem value="DISPATCHED">DISPATCHED</SelectItem>
+                      </SelectItem>
-                    <SelectItem value="ARRIVED">ARRIVED</SelectItem>
+                    ))}
-                    <SelectItem value="CANCELLED">CANCELLED</SelectItem>
                   </SelectContent>
                 </Select>
               </div>
 
-              <div className="overflow-x-auto rounded-2xl border border-border">
+              <div className="space-y-2">
-                <table className="min-w-full divide-y divide-border text-sm">
+                <label className="text-sm font-medium">Departure date</label>
-                  <thead className="bg-muted/40 text-left text-xs uppercase tracking-wide text-muted-foreground">
+                <input
-                    <tr>
+                  className={inputClassName}
-                      <th className="px-3 py-3">Schedule</th>
+                  type="date"
-                      <th className="px-3 py-3">Departure</th>
+                  value={scheduleDate}
-                      <th className="px-3 py-3">Route</th>
+                  onChange={(event) => setScheduleDate(event.target.value)}
-                      <th className="px-3 py-3">Locomotive</th>
+                />
-                      <th className="px-3 py-3">Bookings</th>
-                      <th className="px-3 py-3">Wagons</th>
-                      <th className="px-3 py-3">Weight</th>
-                      <th className="px-3 py-3">Length</th>
-                      <th className="px-3 py-3">Status</th>
-                      <th className="px-3 py-3">Actions</th>
-                    </tr>
-                  </thead>
-                  <tbody className="divide-y divide-border bg-card">
-                    {filteredSchedules.map((schedule) => (
-                      <tr key={schedule.id} className="hover:bg-muted/20">
-                        <td className="px-3 py-3 font-mono text-xs">{schedule.id}</td>
-                        <td className="px-3 py-3">{formatDate(schedule.scheduleDate)}</td>
-                        <td className="px-3 py-3">
-                          {schedule.origin} to {schedule.destination}
-                        </td>
-                        <td className="px-3 py-3">{schedule.locomotive?.code ?? '-'}</td>
-                        <td className="px-3 py-3">{schedule.bookingsCount}</td>
-                        <td className="px-3 py-3">{schedule.wagonCount}</td>
-                        <td className="px-3 py-3">{schedule.totalWeightTons} T</td>
-                        <td className="px-3 py-3">{schedule.totalLengthMeters} m</td>
-                        <td className="px-3 py-3">{schedule.status}</td>
-                        <td className="px-3 py-3">
-                          <div className="flex gap-2">
-                            <Button variant="outline" size="sm" onClick={() => setDetailId(schedule.id)}>
-                              View
-                            </Button>
-                            {schedule.status !== 'CANCELLED' ? (
-                              <Button
-                                variant="outline"
-                                size="sm"
-                                onClick={() => cancelMutation.mutate(schedule.id)}
-                              >
-                                Cancel
-                              </Button>
-                            ) : null}
-                          </div>
-                        </td>
-                      </tr>
-                    ))}
-                    {!schedulesQuery.isLoading && filteredSchedules.length === 0 ? (
-                      <tr>
-                        <td className="px-3 py-8 text-center text-sm text-muted-foreground" colSpan={10}>
-                          No train schedules matched the current filters.
-                        </td>
-                      </tr>
-                    ) : null}
-                  </tbody>
-                </table>
               </div>
-            </section>
+
-          </div>
+              <div className="space-y-2">
+                <label className="text-sm font-medium">Locomotive</label>
+                <Select value={selectedLocomotiveId} onValueChange={setSelectedLocomotiveId}>
+                  <SelectTrigger>
+                    <SelectValue placeholder="Select available locomotive" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {(locomotivesQuery.data ?? []).map((locomotive) => (
+                      <SelectItem key={locomotive.id} value={locomotive.id}>
+                        {locomotive.code} - {locomotive.maxPullWeightTons}T / {locomotive.maxTrainLengthMeters}m
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+            </div>
+
+            <div className="mt-5 grid gap-3 sm:grid-cols-2">
+              <div className="rounded-xl border border-border bg-card p-4">
+                <p className="text-xs uppercase tracking-wide text-muted-foreground">Origin</p>
+                <p className="mt-2 text-sm font-medium">
+                  {selectedRoute?.originYard?.label ?? selectedRoute?.originYard?.code ?? '-'}
+                </p>
+              </div>
+              <div className="rounded-xl border border-border bg-card p-4">
+                <p className="text-xs uppercase tracking-wide text-muted-foreground">Destination</p>
+                <p className="mt-2 text-sm font-medium">
+                  {selectedRoute?.destinationYard?.label ?? selectedRoute?.destinationYard?.code ?? '-'}
+                </p>
+              </div>
+              <div className="rounded-xl border border-border bg-card p-4">
+                <p className="text-xs uppercase tracking-wide text-muted-foreground">Locomotive capacity</p>
+                <p className="mt-2 text-sm font-medium">
+                  {selectedLocomotive
+                    ? `${selectedLocomotive.maxPullWeightTons}T / ${selectedLocomotive.maxTrainLengthMeters}m`
+                    : '-'}
+                </p>
+              </div>
+              <div className="rounded-xl border border-border bg-card p-4">
+                <p className="text-xs uppercase tracking-wide text-muted-foreground">Next step</p>
+                <p className="mt-2 text-sm font-medium">Assign bookings, then allocate wagons</p>
+              </div>
+            </div>
+
+            <div className="mt-5">
+              <Button className="w-full" disabled={isBusy} onClick={() => createMutation.mutate()}>
+                Create schedule
+              </Button>
+            </div>
+          </section>
+
+          <section className="rounded-2xl border border-border bg-background/60 p-5">
+            <div className="mb-4 flex items-center justify-between">
+              <div>
+                <h2 className="text-lg font-semibold">Created schedules</h2>
+                <p className="text-sm text-muted-foreground">
+                  Open a schedule to inspect the reserved locomotive and prepare for later booking and wagon work.
+                </p>
+              </div>
+              <span className="rounded-full bg-muted px-3 py-1 text-xs font-medium text-muted-foreground">
+                {filteredSchedules.length} schedules
+              </span>
+            </div>
+
+            <div className="mb-4 grid gap-3 md:grid-cols-[1fr,220px]">
+              <input
+                className={inputClassName}
+                placeholder="Search by schedule, route, locomotive, or status"
+                value={scheduleSearch}
+                onChange={(event) => setScheduleSearch(event.target.value)}
+              />
+              <Select value={scheduleStatusFilter} onValueChange={setScheduleStatusFilter}>
+                <SelectTrigger>
+                  <SelectValue placeholder="All statuses" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="ALL">All statuses</SelectItem>
+                  <SelectItem value="DRAFT">DRAFT</SelectItem>
+                  <SelectItem value="SCHEDULED">SCHEDULED</SelectItem>
+                  <SelectItem value="DISPATCHED">DISPATCHED</SelectItem>
+                  <SelectItem value="ARRIVED">ARRIVED</SelectItem>
+                  <SelectItem value="CANCELLED">CANCELLED</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div className="overflow-x-auto rounded-2xl border border-border">
+              <table className="min-w-full divide-y divide-border text-sm">
+                <thead className="bg-muted/40 text-left text-xs uppercase tracking-wide text-muted-foreground">
+                  <tr>
+                    <th className="px-3 py-3">Schedule</th>
+                    <th className="px-3 py-3">Departure</th>
+                    <th className="px-3 py-3">Route</th>
+                    <th className="px-3 py-3">Locomotive</th>
+                    <th className="px-3 py-3">Bookings</th>
+                    <th className="px-3 py-3">Wagons</th>
+                    <th className="px-3 py-3">Weight</th>
+                    <th className="px-3 py-3">Length</th>
+                    <th className="px-3 py-3">Status</th>
+                    <th className="px-3 py-3">Actions</th>
+                  </tr>
+                </thead>
+                <tbody className="divide-y divide-border bg-card">
+                  {filteredSchedules.map((schedule) => (
+                    <tr key={schedule.id} className="hover:bg-muted/20">
+                      <td className="px-3 py-3 font-mono text-xs">{schedule.id}</td>
+                      <td className="px-3 py-3">{formatDate(schedule.scheduleDate)}</td>
+                      <td className="px-3 py-3">
+                        {schedule.routeName ?? `${schedule.origin ?? '-'} to ${schedule.destination ?? '-'}`}
+                      </td>
+                      <td className="px-3 py-3">{schedule.locomotive?.code ?? '-'}</td>
+                      <td className="px-3 py-3">{schedule.bookingsCount}</td>
+                      <td className="px-3 py-3">{schedule.wagonCount}</td>
+                      <td className="px-3 py-3">{schedule.totalWeightTons} T</td>
+                      <td className="px-3 py-3">{schedule.totalLengthMeters} m</td>
+                      <td className="px-3 py-3">{schedule.status}</td>
+                      <td className="px-3 py-3">
+                        <div className="flex gap-2">
+                          <Button variant="outline" size="sm" onClick={() => setDetailId(schedule.id)}>
+                            View
+                          </Button>
+                          {schedule.status !== 'CANCELLED' ? (
+                            <Button
+                              variant="outline"
+                              size="sm"
+                              onClick={() => cancelMutation.mutate(schedule.id)}
+                            >
+                              Cancel
+                            </Button>
+                          ) : null}
+                        </div>
+                      </td>
+                    </tr>
+                  ))}
+                  {!schedulesQuery.isLoading && filteredSchedules.length === 0 ? (
+                    <tr>
+                      <td className="px-3 py-8 text-center text-sm text-muted-foreground" colSpan={10}>
+                        No train schedules matched the current filters.
+                      </td>
+                    </tr>
+                  ) : null}
+                </tbody>
+              </table>
+            </div>
+          </section>
         </div>
       </section>
 
@@ -634,13 +375,13 @@ const TrainsPage = () => {
           <DialogHeader>
             <DialogTitle>Train schedule detail</DialogTitle>
             <DialogDescription>
-              Inspect the selected schedule, locomotive, wagons, and booking allocations.
+              Inspect the selected schedule. Booking assignment and wagon allocation happen after schedule creation.
             </DialogDescription>
           </DialogHeader>
 
           {detail ? (
             <div className="space-y-6">
-              <div className="grid gap-4 md:grid-cols-2 xl:grid-cols-4">
+              <div className="grid gap-4 md:grid-cols-2 xl:grid-cols-5">
                 <div className="rounded-xl border border-border p-4">
                   <p className="text-xs uppercase tracking-wide text-muted-foreground">Schedule</p>
                   <p className="mt-2 break-all font-mono text-xs">{detail.id}</p>
@@ -651,6 +392,10 @@ const TrainsPage = () => {
                 </div>
                 <div className="rounded-xl border border-border p-4">
                   <p className="text-xs uppercase tracking-wide text-muted-foreground">Route</p>
+                  <p className="mt-2 text-sm font-medium">{detail.route?.name ?? '-'}</p>
+                </div>
+                <div className="rounded-xl border border-border p-4">
+                  <p className="text-xs uppercase tracking-wide text-muted-foreground">Origin / destination</p>
                   <p className="mt-2 text-sm font-medium">
                     {detail.originStation?.label ?? detail.originStation?.code ?? '-'} to{' '}
                     {detail.destinationStation?.label ?? detail.destinationStation?.code ?? '-'}
@@ -666,73 +411,63 @@ const TrainsPage = () => {
                 <h3 className="text-lg font-semibold">Locomotive</h3>
                 <p className="mt-2 text-sm text-muted-foreground">
                   {detail.trainSet?.locomotive
-                    ? `${detail.trainSet.locomotive.code} (${detail.trainSet.locomotive.maxPullWeightTons}T pull capacity)`
+                    ? `${detail.trainSet.locomotive.code} (${detail.trainSet.locomotive.maxPullWeightTons}T pull capacity / ${detail.trainSet.locomotive.maxTrainLengthMeters ?? 0}m)`
                     : 'No locomotive attached'}
                 </p>
               </div>
 
               <div className="rounded-2xl border border-border p-4">
                 <h3 className="text-lg font-semibold">Wagons and allocations</h3>
-                <div className="mt-4 space-y-4">
+                {(detail.trainSet?.wagons?.length ?? 0) === 0 ? (
-                  {(detail.trainSet?.wagons ?? []).map((wagon) => (
+                  <p className="mt-3 text-sm text-muted-foreground">No wagons allocated yet.</p>
-                    <div key={wagon.id} className="rounded-xl border border-border p-4">
+                ) : (
-                      <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
+                  <div className="mt-4 space-y-4">
-                        <div>
+                    {(detail.trainSet?.wagons ?? []).map((wagon) => (
-                          <p className="font-semibold">
+                      <div key={wagon.id} className="rounded-xl border border-border p-4">
-                            Wagon {wagon.sequenceNo} - {wagon.wagonType?.code ?? 'NW5'}
+                        <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
-                          </p>
+                          <div>
-                          <p className="text-sm text-muted-foreground">
+                            <p className="font-semibold">
-                            {wagon.assignedWeightTons}T assigned / {wagon.capacityTons}T capacity / {wagon.lengthMeters}m
+                              Wagon {wagon.sequenceNo} - {wagon.wagonType?.code ?? 'NW5'}
-                          </p>
+                            </p>
+                            <p className="text-sm text-muted-foreground">
+                              {wagon.assignedWeightTons}T assigned / {wagon.capacityTons}T capacity / {wagon.lengthMeters}m
+                            </p>
+                          </div>
                         </div>
                       </div>
-                      <div className="mt-3 overflow-x-auto rounded-xl border border-border">
+                    ))}
-                        <table className="min-w-full divide-y divide-border text-sm">
+                  </div>
-                          <thead className="bg-muted/40 text-left text-xs uppercase tracking-wide text-muted-foreground">
+                )}
-                            <tr>
-                              <th className="px-3 py-2">Booking</th>
-                              <th className="px-3 py-2">Allocated weight</th>
-                            </tr>
-                          </thead>
-                          <tbody className="divide-y divide-border bg-card">
-                            {wagon.allocations.map((allocation) => (
-                              <tr key={allocation.id}>
-                                <td className="px-3 py-2">{allocation.bookingReference ?? allocation.bookingId}</td>
-                                <td className="px-3 py-2">{allocation.allocatedWeightTons} T</td>
-                              </tr>
-                            ))}
-                          </tbody>
-                        </table>
-                      </div>
-                    </div>
-                  ))}
-                </div>
               </div>
 
               <div className="rounded-2xl border border-border p-4">
                 <h3 className="text-lg font-semibold">Bookings in schedule</h3>
-                <div className="mt-4 overflow-x-auto rounded-xl border border-border">
+                {detail.bookings.length === 0 ? (
-                  <table className="min-w-full divide-y divide-border text-sm">
+                  <p className="mt-3 text-sm text-muted-foreground">No bookings assigned yet.</p>
-                    <thead className="bg-muted/40 text-left text-xs uppercase tracking-wide text-muted-foreground">
+                ) : (
-                      <tr>
+                  <div className="mt-4 overflow-x-auto rounded-xl border border-border">
-                        <th className="px-3 py-2">Reference</th>
+                    <table className="min-w-full divide-y divide-border text-sm">
-                        <th className="px-3 py-2">Customer</th>
+                      <thead className="bg-muted/40 text-left text-xs uppercase tracking-wide text-muted-foreground">
-                        <th className="px-3 py-2">Weight</th>
+                        <tr>
-                        <th className="px-3 py-2">Status</th>
+                          <th className="px-3 py-2">Reference</th>
-                      </tr>
+                          <th className="px-3 py-2">Customer</th>
-                    </thead>
+                          <th className="px-3 py-2">Weight</th>
-                    <tbody className="divide-y divide-border bg-card">
+                          <th className="px-3 py-2">Status</th>
-                      {detail.bookings.map((booking) => (
-                        <tr key={booking.id}>
-                          <td className="px-3 py-2">{booking.reference ?? booking.id}</td>
-                          <td className="px-3 py-2">{booking.customer ?? '-'}</td>
-                          <td className="px-3 py-2">{booking.weightTons} T</td>
-                          <td className="px-3 py-2">{booking.status ?? '-'}</td>
                         </tr>
-                      ))}
+                      </thead>
-                    </tbody>
+                      <tbody className="divide-y divide-border bg-card">
-                  </table>
+                        {detail.bookings.map((booking) => (
-                </div>
+                          <tr key={booking.id}>
+                            <td className="px-3 py-2">{booking.reference ?? booking.id}</td>
+                            <td className="px-3 py-2">{booking.customer ?? '-'}</td>
+                            <td className="px-3 py-2">{booking.weightTons} T</td>
+                            <td className="px-3 py-2">{booking.status ?? '-'}</td>
+                          </tr>
+                        ))}
+                      </tbody>
+                    </table>
+                  </div>
+                )}
               </div>
             </div>
           ) : (
@@ -743,43 +478,5 @@ const TrainsPage = () => {
     </div>
   );
 };
+
 export default TrainsPage;
-
-// export default function TrainsPage() {
-//   const { data: trains, isLoading } = useTrains();
-//   const deleteTrain = useDeleteTrain();
-//   const [open, setOpen] = useState(false);
-
-//   if (isLoading) return <div className="p-8">Loading trains...</div>;
-
-//   return (
-//     <Card>
-//       <CardHeader className="flex flex-row items-center justify-between">
-//         <CardTitle>Trains</CardTitle>
-//         <Dialog open={open} onOpenChange={setOpen}>
-//           <DialogTrigger asChild><Button size="sm"><Plus className="mr-2 h-4 w-4" />New Train</Button></DialogTrigger>
-//           <DialogContent><DialogHeader><DialogTitle>Create Train</DialogTitle></DialogHeader><CreateTrainForm onSuccess={() => setOpen(false)} /></DialogContent>
-//         </Dialog>
-//       </CardHeader>
-//       <CardContent>
-//         <Table>
-//           <TableHeader><TableRow><TableHead>Number</TableHead><TableHead>Name</TableHead><TableHead>Status</TableHead><TableHead>Capacity</TableHead><TableHead>Actions</TableHead></TableRow></TableHeader>
-//           <TableBody>
-//             {trains?.map(train => (
-//               <TableRow key={train.id}>
-//                 <TableCell>{train.trainNumber || train.code}</TableCell>
-//                 <TableCell>{train.trainName || '-'}</TableCell>
-//                 <TableCell><Badge variant="outline">{train.status}</Badge></TableCell>
-//                 <TableCell>{train.capacityTons} t</TableCell>
-//                 <TableCell className="flex space-x-2">
-//                   <Link to={`/trains/${train.id}`}><Button variant="ghost" size="icon"><Eye className="h-4 w-4" /></Button></Link>
-//                   <Button variant="ghost" size="icon" onClick={() => deleteTrain.mutate(train.id)}><Trash2 className="h-4 w-4" /></Button>
-//                 </TableCell>
-//               </TableRow>
-//             ))}
-//           </TableBody>
-//         </Table>
-//       </CardContent>
-//     </Card>
-//   );
-// }

apps/edr-freight-web/backoffice/src/services/locomotives.service.ts

@@ -0,0 +1,40 @@
+import { api as apiClient } from '../auth/http';
+
+import { URL_CONSTANTS } from '@/constants/URLS';
+
+export type LocomotiveType = 'DIESEL' | 'ELECTRIC';
+export type LocomotiveStatus =
+  | 'AVAILABLE'
+  | 'MAINTENANCE'
+  | 'ASSIGNED'
+  | 'OUT_OF_SERVICE';
+
+export interface Locomotive {
+  id: string;
+  code: string;
+  name?: string | null;
+  locomotiveType: LocomotiveType;
+  status: LocomotiveStatus;
+  maxPullWeightTons: number;
+  maxTrainLengthMeters: number;
+  powerKw?: number | null;
+  tractionForceKn?: number | null;
+  maxSpeedKmh?: number | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type SaveLocomotivePayload = Omit<
+  Locomotive,
+  'id' | 'createdAt' | 'updatedAt'
+>;
+
+export const locomotivesService = {
+  getAll: () => apiClient.get<Locomotive[]>(URL_CONSTANTS.LOCOMOTIVES.BASE),
+  getById: (id: string) => apiClient.get<Locomotive>(URL_CONSTANTS.LOCOMOTIVES.BY_ID(id)),
+  create: (data: Partial<SaveLocomotivePayload>) =>
+    apiClient.post(URL_CONSTANTS.LOCOMOTIVES.BASE, data),
+  update: (id: string, data: Partial<SaveLocomotivePayload>) =>
+    apiClient.patch(URL_CONSTANTS.LOCOMOTIVES.BY_ID(id), data),
+  decommission: (id: string) => apiClient.post(URL_CONSTANTS.LOCOMOTIVES.DECOMMISSION(id), {}),
+};

apps/edr-freight-web/backoffice/src/services/routes.service.ts

@@ -0,0 +1,52 @@
+import { api as apiClient } from '../auth/http';
+
+import { URL_CONSTANTS } from '@/constants/URLS';
+
+export interface YardRef {
+  id: string;
+  code: string;
+  label: string;
+  country?: string;
+}
+
+export interface RouteMilestone {
+  id: string;
+  routeId: string;
+  yardId: string;
+  sequenceNo: number;
+  yard?: YardRef | null;
+}
+
+export interface RouteRecord {
+  id: string;
+  name: string;
+  originYardId: string;
+  destinationYardId: string;
+  isActive: boolean;
+  originYard?: YardRef | null;
+  destinationYard?: YardRef | null;
+  milestones?: RouteMilestone[];
+}
+
+export interface SaveRoutePayload {
+  name: string;
+  milestones: Array<{ yardId: string }>;
+  isActive?: boolean;
+}
+
+interface YardListResponse {
+  data: YardRef[];
+}
+
+export const routesService = {
+  getAll: () => apiClient.get<RouteRecord[]>(URL_CONSTANTS.ROUTES.BASE),
+  getById: (id: string) => apiClient.get<RouteRecord>(URL_CONSTANTS.ROUTES.BY_ID(id)),
+  create: (data: SaveRoutePayload) => apiClient.post(URL_CONSTANTS.ROUTES.BASE, data),
+  update: (id: string, data: Partial<SaveRoutePayload>) =>
+    apiClient.patch(URL_CONSTANTS.ROUTES.BY_ID(id), data),
+  deactivate: (id: string) => apiClient.delete(URL_CONSTANTS.ROUTES.BY_ID(id)),
+  getYards: () =>
+    apiClient.get<YardListResponse>(URL_CONSTANTS.RULE_ENGINE.YARDS, {
+      params: { isActive: true, pageSize: 200 },
+    }),
+};

apps/edr-freight-web/backoffice/src/types/trainScheduling.ts

@@ -56,13 +56,15 @@ export interface LocomotiveRecord {
   code: string;
   name?: string | null;
   maxPullWeightTons: number;
-  status: 'AVAILABLE' | 'ASSIGNED' | 'MAINTENANCE' | 'INACTIVE';
+  maxTrainLengthMeters: number;
-  availableFrom?: string | null;
+  status: 'AVAILABLE' | 'ASSIGNED' | 'MAINTENANCE' | 'OUT_OF_SERVICE';
+  locomotiveType?: 'DIESEL' | 'ELECTRIC';
 }
 
 export interface TrainScheduleListItem {
   id: string;
   scheduleDate: string;
+  routeName?: string | null;
   origin: string | null;
   destination: string | null;
   locomotive:
@@ -82,6 +84,10 @@ export interface TrainScheduleListItem {
 export interface TrainScheduleDetail {
   id: string;
   status: string;
+  route?: {
+    id: string;
+    name: string;
+  } | null;
   scheduledDepartureDate: string;
   scheduledArrivalDate?: string | null;
   originStation?: {
@@ -100,13 +106,14 @@ export interface TrainScheduleDetail {
     wagonCount: number;
     totalWeightTons: number;
     totalLengthMeters: number;
-    locomotive?: {
+      locomotive?: {
-      id: string;
+        id: string;
-      code: string;
+        code: string;
-      name?: string | null;
+        name?: string | null;
-      status: string;
+        status: string;
-      maxPullWeightTons: number;
+        maxPullWeightTons: number;
-    } | null;
+        maxTrainLengthMeters?: number;
+      } | null;
     wagons: Array<{
       id: string;
       sequenceNo: number;
@@ -148,6 +155,8 @@ export interface TrainSchedulePreviewPayload {
   destinationStationId: string;
 }
 
-export interface CreateTrainSchedulePayload extends TrainSchedulePreviewPayload {
+export interface CreateTrainSchedulePayload {
+  routeId: string;
+  scheduleDate: string;
   locomotiveId: string;
 }