feat: complete train scheduling integration

apps/edr-freight-api/src/migrations/1750200000000-SeedDefaultWagonTypes.ts

@@ -0,0 +1,46 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class SeedDefaultWagonTypes1750200000000 implements MigrationInterface {
+  name = 'SeedDefaultWagonTypes1750200000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      INSERT INTO freight.wagon_types (
+        code,
+        name,
+        capacity_tons,
+        length_meters,
+        max_wagons_per_train,
+        supported_load_types,
+        is_active
+      )
+      VALUES
+        ('NW7', 'Double deck sedan wagon', 22, 26.066, NULL, ARRAY['vehicles', 'sedan'], true),
+        ('NW5', 'Flat wagon (container)', 70, 14.000, 53, ARRAY['container', 'steel', 'machinery'], true),
+        ('PW2', 'Box wagon', 70, 17.066, 18, ARRAY['general cargo', 'break bulk'], true),
+        ('GW2', 'Tank wagon', 70, 12.228, 37, ARRAY['liquid', 'fuel'], true),
+        ('CW4', 'Gondola covered wagon', 70, 13.976, 37, ARRAY['covered bulk cargo'], true),
+        ('CW3', 'Gondola open wagon', 70, 13.976, NULL, ARRAY['open bulk cargo'], true),
+        ('KW2', 'Hopper covered wagon', 69, 16.466, NULL, ARRAY['bulk grains'], true),
+        ('KW3', 'Hopper open wagon', 70, 14.400, NULL, ARRAY['coal', 'bulk cargo'], true),
+        ('NW6', 'Flat wagon (long cargo)', 70, 18.560, NULL, ARRAY['long cargo'], true),
+        ('BW1', 'Refrigerated wagon', 38, 21.996, NULL, ARRAY['refrigerated cargo'], true)
+      ON CONFLICT (code) DO UPDATE SET
+        name = EXCLUDED.name,
+        capacity_tons = EXCLUDED.capacity_tons,
+        length_meters = EXCLUDED.length_meters,
+        max_wagons_per_train = EXCLUDED.max_wagons_per_train,
+        supported_load_types = EXCLUDED.supported_load_types,
+        is_active = true,
+        deleted_at = NULL,
+        updated_at = now();
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM freight.wagon_types
+      WHERE code IN ('NW7', 'NW5', 'PW2', 'GW2', 'CW4', 'CW3', 'KW2', 'KW3', 'NW6', 'BW1');
+    `);
+  }
+}

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

@@ -2,13 +2,14 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Cargo } from './entities/cargoes.entity';
 import { Container } from '../container-management/entities/container.entity';
+import { CargoType } from '../rule-engine/entities/cargo-type.entity';
 import { CargoesController } from './cargoes.controller';
 import { CargoesService } from './cargoes.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Cargo, Container])],
+  imports: [TypeOrmModule.forFeature([Cargo, Container, CargoType])],
   controllers: [CargoesController],
   providers: [CargoesService],
   exports: [CargoesService],
 })
-export class CargoesModule {}
+export class CargoesModule {}

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

@@ -7,6 +7,7 @@ import { LoadCargoDto } from './dto/load-cargo.dto';
 import { DeliverCargoDto } from './dto/deliver-cargo.dto';
 import { Cargo } from './entities/cargoes.entity';
 import { Container } from '../container-management/entities/container.entity';
+import { CargoType } from '../rule-engine/entities/cargo-type.entity';
 
 @Injectable()
 export class CargoesService {
@@ -15,9 +16,30 @@ export class CargoesService {
     private readonly cargoRepo: Repository<Cargo>,
     @InjectRepository(Container)
     private readonly containerRepo: Repository<Container>,
+    @InjectRepository(CargoType)
+    private readonly cargoTypeRepo: Repository<CargoType>,
   ) {}
 
   async create(dto: CreateCargoDto): Promise<Cargo> {
+    const existing = await this.cargoRepo.findOne({
+      where: { cargoReference: dto.cargoReference },
+    });
+    if (existing) {
+      throw new ConflictException(`Cargo reference "${dto.cargoReference}" already exists`);
+    }
+
+    const container = await this.containerRepo.findOne({ where: { id: dto.containerId } });
+    if (!container) {
+      throw new NotFoundException(`Container ${dto.containerId} not found`);
+    }
+
+    if (dto.cargoTypeId) {
+      const cargoType = await this.cargoTypeRepo.findOne({
+        where: { id: dto.cargoTypeId, isActive: true },
+      });
+      if (!cargoType) throw new NotFoundException(`Cargo type ${dto.cargoTypeId} not found`);
+    }
+
     const cargo = this.cargoRepo.create(dto);
     return this.cargoRepo.save(cargo);
   }
@@ -62,6 +84,24 @@ export class CargoesService {
 
   async update(id: string, dto: UpdateCargoDto): Promise<Cargo> {
     const cargo = await this.findById(id);
+    if (dto.cargoReference && dto.cargoReference !== cargo.cargoReference) {
+      const existing = await this.cargoRepo.findOne({
+        where: { cargoReference: dto.cargoReference },
+      });
+      if (existing) {
+        throw new ConflictException(`Cargo reference "${dto.cargoReference}" already exists`);
+      }
+    }
+    if (dto.containerId) {
+      const container = await this.containerRepo.findOne({ where: { id: dto.containerId } });
+      if (!container) throw new NotFoundException(`Container ${dto.containerId} not found`);
+    }
+    if (dto.cargoTypeId) {
+      const cargoType = await this.cargoTypeRepo.findOne({
+        where: { id: dto.cargoTypeId, isActive: true },
+      });
+      if (!cargoType) throw new NotFoundException(`Cargo type ${dto.cargoTypeId} not found`);
+    }
     Object.assign(cargo, dto);
     return this.cargoRepo.save(cargo);
   }

apps/edr-freight-api/src/modules/container-management/containers.module.ts

@@ -3,12 +3,13 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Container } from './entities/container.entity';
 import { Wagon } from '../wagons/entities/wagon.entity';
+import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { ContainersController } from './containers.controller';
 import { ContainersService } from './containers.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Container, Wagon])],   // ✅ add Wagon
+  imports: [TypeOrmModule.forFeature([Container, Wagon, ContainerType])],
   controllers: [ContainersController],
   providers: [ContainersService],
 })
-export class ContainersModule {}
+export class ContainersModule {}

apps/edr-freight-api/src/modules/container-management/containers.service.ts

@@ -7,6 +7,7 @@ import { UpdateContainerDto } from './dto/update-container.dto';
 import { AssignContainerToWagonDto } from './dto/assign-container-to-wagon.dto';
 import { Container } from './entities/container.entity';
 import { Wagon } from '../wagons/entities/wagon.entity';
+import { ContainerType } from '../rule-engine/entities/container-type.entity';
 
 @Injectable()
 export class ContainersService {
@@ -15,9 +16,30 @@ export class ContainersService {
     private readonly containerRepo: Repository<Container>,
     @InjectRepository(Wagon)
     private readonly wagonRepo: Repository<Wagon>,   // ✅ use raw repository
+    @InjectRepository(ContainerType)
+    private readonly containerTypeRepo: Repository<ContainerType>,
   ) {}
 
   async create(dto: CreateContainerDto): Promise<Container> {
+    const existing = await this.containerRepo.findOne({
+      where: { containerNumber: dto.containerNumber },
+    });
+    if (existing) {
+      throw new ConflictException(`Container number "${dto.containerNumber}" already exists`);
+    }
+
+    const containerType = await this.containerTypeRepo.findOne({
+      where: { id: dto.containerTypeId, isActive: true },
+    });
+    if (!containerType) {
+      throw new NotFoundException(`Container type ${dto.containerTypeId} not found`);
+    }
+
+    if (dto.wagonId) {
+      const wagon = await this.wagonRepo.findOne({ where: { id: dto.wagonId } });
+      if (!wagon) throw new NotFoundException(`Wagon ${dto.wagonId} not found`);
+    }
+
     const container = this.containerRepo.create(dto);
     if (dto.wagonId === undefined) container.wagonId = null;
     if (dto.position === undefined) container.position = null;
@@ -59,6 +81,26 @@ export class ContainersService {
 
   async update(id: string, dto: UpdateContainerDto): Promise<Container> {
     const container = await this.findById(id);
+    if (dto.containerNumber && dto.containerNumber !== container.containerNumber) {
+      const existing = await this.containerRepo.findOne({
+        where: { containerNumber: dto.containerNumber },
+      });
+      if (existing) {
+        throw new ConflictException(`Container number "${dto.containerNumber}" already exists`);
+      }
+    }
+    if (dto.containerTypeId) {
+      const containerType = await this.containerTypeRepo.findOne({
+        where: { id: dto.containerTypeId, isActive: true },
+      });
+      if (!containerType) {
+        throw new NotFoundException(`Container type ${dto.containerTypeId} not found`);
+      }
+    }
+    if (dto.wagonId) {
+      const wagon = await this.wagonRepo.findOne({ where: { id: dto.wagonId } });
+      if (!wagon) throw new NotFoundException(`Wagon ${dto.wagonId} not found`);
+    }
     Object.assign(container, dto);
     return this.containerRepo.save(container);
   }

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

@@ -4,11 +4,6 @@ import { Public } from "@edr/api-common";
 import { randomUUID } from "crypto";
 import { Response } from "express"
 
-import * as fs from 'fs';
-import * as path from 'path';
-import Handlebars from 'handlebars';
-
-
 @Public()
 @Controller("payments")
 export class PaymentController {
@@ -86,4 +81,4 @@ export class PaymentController {
 
 
 
-}
+}

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

@@ -118,9 +118,11 @@ export class TrainSchedulingService {
       );
     }
 
-    queryBuilder.andWhere("booking.status = :status", {
-      status: query.status ?? "PAID",
-    });
+    if (query.status) {
+      queryBuilder.andWhere("booking.status = :status", {
+        status: query.status,
+      });
+    }
 
     const bookings = await queryBuilder
       .orderBy("booking.scheduled_date", "ASC")

apps/edr-freight-api/src/modules/wagon-types/wagon-types.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, Get } from '@nestjs/common';
+import { ApiTags, ApiOperation } from '@nestjs/swagger';
+import { WagonTypesService } from './wagon-types.service';
+import { WagonType } from './entities/wagon-type.entity';
+
+@ApiTags('Wagon Types')
+@Controller('wagon-types')
+export class WagonTypesController {
+  constructor(private readonly wagonTypesService: WagonTypesService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Get all active wagon types' })
+  async findAll(): Promise<WagonType[]> {
+    return this.wagonTypesService.findAll();
+  }
+}

apps/edr-freight-api/src/modules/wagon-types/wagon-types.module.ts

@@ -2,11 +2,13 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { WagonType } from './entities/wagon-type.entity';
+import { WagonTypesController } from './wagon-types.controller';
 import { WagonTypesRepository } from './wagon-types.repository';
 import { WagonTypesService } from './wagon-types.service';
 
 @Module({
   imports: [TypeOrmModule.forFeature([WagonType])],
+  controllers: [WagonTypesController],
   providers: [WagonTypesRepository, WagonTypesService],
   exports: [WagonTypesRepository, WagonTypesService],
 })

apps/edr-freight-api/src/modules/wagon-types/wagon-types.service.ts

@@ -7,6 +7,13 @@ import { WagonTypesRepository } from './wagon-types.repository';
 export class WagonTypesService {
   constructor(private readonly wagonTypesRepository: WagonTypesRepository) {}
 
+  async findAll(): Promise<WagonType[]> {
+    return this.wagonTypesRepository.findAll({
+      where: { isActive: true },
+      order: { code: 'ASC' },
+    });
+  }
+
   async findByCode(code: string): Promise<WagonType> {
     const [wagonType] = await this.wagonTypesRepository.findAll({ where: { code } });