mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-28 00:50:56 +00:00
778 lines
24 KiB
TypeScript
778 lines
24 KiB
TypeScript
import { Injectable, Logger } from "@nestjs/common";
|
||
import { DataSource } from "typeorm";
|
||
|
||
import { BookingCargoModifier } from "../modules/bookings/entities/booking-cargo-modifier.entity";
|
||
import { CargoType } from "../modules/rule-engine/entities/cargo-type.entity";
|
||
import { ContainerType } from "../modules/rule-engine/entities/container-type.entity";
|
||
import { PriorityConfig } from "../modules/rule-engine/entities/priority-config.entity";
|
||
import { Rate } from "../modules/rule-engine/entities/rate.entity";
|
||
import { ServiceType } from "../modules/rule-engine/entities/service-type.entity";
|
||
import { ShippingLine } from "../modules/rule-engine/entities/shipping-line.entity";
|
||
import { SurchargeType } from "../modules/rule-engine/entities/surcharge-type.entity";
|
||
import { WeightLimitRule } from "../modules/rule-engine/entities/weight-limit-rule.entity";
|
||
import { Route } from "../modules/routes/entities/route.entity";
|
||
import { RouteMilestone } from "../modules/routes/entities/route-milestone.entity";
|
||
import { Yard } from "../modules/rule-engine/entities/yard.entity";
|
||
|
||
const STAFF_USER_ID = "00000000-0000-0000-0000-000000000001";
|
||
const CEO_USER_ID = "00000000-0000-0000-0000-000000000002";
|
||
|
||
@Injectable()
|
||
export class PricingDataSeeder {
|
||
private readonly logger = new Logger(PricingDataSeeder.name);
|
||
|
||
constructor(private readonly dataSource: DataSource) { }
|
||
|
||
async run(): Promise<void> {
|
||
await this.dataSource.transaction(async (manager) => {
|
||
const ctRepo = manager.getRepository(ContainerType);
|
||
const stRepo = manager.getRepository(ServiceType);
|
||
const yRepo = manager.getRepository(Yard);
|
||
const slRepo = manager.getRepository(ShippingLine);
|
||
const wlRepo = manager.getRepository(WeightLimitRule);
|
||
const prRepo = manager.getRepository(PriorityConfig);
|
||
const rRepo = manager.getRepository(Rate);
|
||
|
||
await this.upsertReferenceData(manager, ctRepo, stRepo, yRepo, slRepo);
|
||
await this.seedDomesticRoute(manager, yRepo);
|
||
await this.seedWeightLimits(wlRepo, ctRepo);
|
||
await this.seedPriorityConfigs(prRepo);
|
||
const containerTypes = await ctRepo.find();
|
||
const ctByCode = new Map(containerTypes.map((ct) => [ct.code, ct]));
|
||
|
||
const rates = await this.seedRates(rRepo, ctByCode);
|
||
const ratesByType = new Map<string, Rate[]>();
|
||
for (const r of rates) {
|
||
const key = `${r.rateType}|${r.currency}|${r.containerTypeId ?? ""}`;
|
||
if (!ratesByType.has(key)) ratesByType.set(key, []);
|
||
ratesByType.get(key)!.push(r);
|
||
}
|
||
|
||
await this.seedSurchargeTypes(manager, ratesByType);
|
||
|
||
const yards = await yRepo.find();
|
||
const yardByCode = new Map(yards.map((y) => [y.code, y]));
|
||
const serviceTypes = await stRepo.find();
|
||
const stByCode = new Map(serviceTypes.map((st) => [st.code, st]));
|
||
const shippingLines = await slRepo.find();
|
||
const slByCode = new Map(shippingLines.map((sl) => [sl.code, sl]));
|
||
const cargoTypes = await manager.getRepository(CargoType).find();
|
||
const cargoByCode = new Map(cargoTypes.map((c) => [c.code, c]));
|
||
|
||
await this.seedDraftBookings(
|
||
ctByCode,
|
||
yardByCode,
|
||
stByCode,
|
||
slByCode,
|
||
cargoByCode,
|
||
);
|
||
});
|
||
|
||
this.logger.log("Seeded pricing data");
|
||
}
|
||
|
||
private async upsertReferenceData(
|
||
manager: any,
|
||
ctRepo: any,
|
||
stRepo: any,
|
||
yRepo: any,
|
||
slRepo: any,
|
||
): Promise<void> {
|
||
await yRepo.upsert(
|
||
[
|
||
{
|
||
code: "DJIBOUTI",
|
||
label: "Djibouti",
|
||
country: "Djibouti",
|
||
displayOrder: 1,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "ADDIS_ABABA",
|
||
label: "Addis Ababa",
|
||
country: "Ethiopia",
|
||
displayOrder: 2,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "DIRE_DAWA",
|
||
label: "Dire Dawa",
|
||
country: "Ethiopia",
|
||
displayOrder: 3,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "MODJO",
|
||
label: "Modjo",
|
||
country: "Ethiopia",
|
||
displayOrder: 4,
|
||
isActive: true,
|
||
},
|
||
],
|
||
{ conflictPaths: { code: true } },
|
||
);
|
||
|
||
await ctRepo.upsert(
|
||
[
|
||
{
|
||
code: "20FT",
|
||
label: "20FT Standard",
|
||
sizeFt: 20,
|
||
wagonsPerUnit: 0.5,
|
||
isReefer: false,
|
||
isOpenTop: false,
|
||
isActive: true,
|
||
displayOrder: 1,
|
||
},
|
||
{
|
||
code: "40FT",
|
||
label: "40FT Standard",
|
||
sizeFt: 40,
|
||
wagonsPerUnit: 1,
|
||
isReefer: false,
|
||
isOpenTop: false,
|
||
isActive: true,
|
||
displayOrder: 2,
|
||
},
|
||
{
|
||
code: "20FT_REEFER",
|
||
label: "20FT Reefer",
|
||
sizeFt: 20,
|
||
wagonsPerUnit: 0.5,
|
||
isReefer: true,
|
||
isOpenTop: false,
|
||
isActive: true,
|
||
displayOrder: 3,
|
||
},
|
||
{
|
||
code: "40FT_REEFER",
|
||
label: "40FT Reefer",
|
||
sizeFt: 40,
|
||
wagonsPerUnit: 1,
|
||
isReefer: true,
|
||
isOpenTop: false,
|
||
isActive: true,
|
||
displayOrder: 4,
|
||
},
|
||
],
|
||
{ conflictPaths: { code: true } },
|
||
);
|
||
|
||
await stRepo.upsert(
|
||
[
|
||
{
|
||
code: "RAIL_CONTAINER",
|
||
serviceName: "Rail Container Service",
|
||
description: "Standard rail container transport",
|
||
canBeBookedAlone: true,
|
||
includesFirstMile: false,
|
||
includesLastMile: false,
|
||
includesCustoms: false,
|
||
priorityBonusPoints: 0,
|
||
isActive: true,
|
||
displayOrder: 1,
|
||
},
|
||
{
|
||
code: "RAIL_FORWARDING",
|
||
serviceName: "Rail Forwarding Service",
|
||
description: "Rail transport with first/last mile and customs",
|
||
canBeBookedAlone: true,
|
||
includesFirstMile: true,
|
||
includesLastMile: true,
|
||
includesCustoms: true,
|
||
priorityBonusPoints: 100,
|
||
isActive: true,
|
||
displayOrder: 2,
|
||
},
|
||
{
|
||
code: "RAIL_BULK",
|
||
serviceName: "Rail Bulk Transport",
|
||
description: "Bulk commodity rail transport",
|
||
canBeBookedAlone: true,
|
||
includesFirstMile: false,
|
||
includesLastMile: false,
|
||
includesCustoms: false,
|
||
priorityBonusPoints: 50,
|
||
isActive: true,
|
||
displayOrder: 3,
|
||
},
|
||
],
|
||
{ conflictPaths: { code: true } },
|
||
);
|
||
|
||
await slRepo.upsert(
|
||
[
|
||
{
|
||
code: "MAERSK",
|
||
label: "Maersk Line",
|
||
mappedToCode: "MAERSK",
|
||
showExtraFeeNotice: true,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "MSC",
|
||
label: "MSC",
|
||
mappedToCode: "MSC",
|
||
showExtraFeeNotice: true,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "CMA_CGM",
|
||
label: "CMA CGM",
|
||
mappedToCode: "CMA_CGM",
|
||
showExtraFeeNotice: true,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "COSCO",
|
||
label: "COSCO Shipping",
|
||
mappedToCode: "COSCO",
|
||
showExtraFeeNotice: true,
|
||
isActive: true,
|
||
},
|
||
{
|
||
code: "OTHER",
|
||
label: "Other Line",
|
||
mappedToCode: null,
|
||
showExtraFeeNotice: false,
|
||
isActive: true,
|
||
},
|
||
],
|
||
{ conflictPaths: { code: true } },
|
||
);
|
||
|
||
await manager.getRepository(CargoType).upsert(
|
||
[
|
||
{
|
||
code: "GRAIN",
|
||
cargoTypeName: "Grain / Cereals",
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 1,
|
||
},
|
||
{
|
||
code: "FERTILIZER",
|
||
cargoTypeName: "Fertilizer",
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 2,
|
||
},
|
||
{
|
||
code: "CEMENT",
|
||
cargoTypeName: "Cement / Clinker",
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 3,
|
||
},
|
||
{
|
||
code: "STEEL",
|
||
cargoTypeName: "Steel / Rebar",
|
||
requiresDirectorApproval: true,
|
||
isActive: true,
|
||
displayOrder: 4,
|
||
},
|
||
{
|
||
code: "MACHINERY",
|
||
cargoTypeName: "Heavy Machinery",
|
||
requiresDirectorApproval: true,
|
||
isActive: true,
|
||
displayOrder: 5,
|
||
},
|
||
{
|
||
code: "OTHER_BULK",
|
||
cargoTypeName: "Other Bulk Cargo",
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 6,
|
||
},
|
||
],
|
||
{ conflictPaths: { code: true } },
|
||
);
|
||
}
|
||
|
||
private async seedDomesticRoute(manager: any, yRepo: any): Promise<void> {
|
||
const addis = await yRepo.findOneBy({ code: "ADDIS_ABABA" });
|
||
const direDawa = await yRepo.findOneBy({ code: "DIRE_DAWA" });
|
||
if (!addis || !direDawa) return;
|
||
|
||
const routeRepo = manager.getRepository(Route);
|
||
const milestoneRepo = manager.getRepository(RouteMilestone);
|
||
const routeName = "Addis Ababa → Dire Dawa";
|
||
let route = await routeRepo.findOneBy({ name: routeName });
|
||
if (!route) {
|
||
route = await routeRepo.save(
|
||
routeRepo.create({
|
||
name: routeName,
|
||
originYardId: addis.id,
|
||
destinationYardId: direDawa.id,
|
||
isActive: true,
|
||
}),
|
||
);
|
||
await milestoneRepo.save([
|
||
milestoneRepo.create({
|
||
routeId: route.id,
|
||
yardId: addis.id,
|
||
sequenceNo: 1,
|
||
}),
|
||
milestoneRepo.create({
|
||
routeId: route.id,
|
||
yardId: direDawa.id,
|
||
sequenceNo: 2,
|
||
}),
|
||
]);
|
||
this.logger.log("Seeded domestic route Addis Ababa → Dire Dawa");
|
||
}
|
||
}
|
||
|
||
private async seedWeightLimits(wlRepo: any, ctRepo: any): Promise<void> {
|
||
const twenty = await ctRepo.findOneByOrFail({ code: "20FT" });
|
||
const forty = await ctRepo.findOneByOrFail({ code: "40FT" });
|
||
|
||
const base = new Date("2026-01-01");
|
||
|
||
const rules = [
|
||
{
|
||
containerTypeId: twenty.id,
|
||
tradeDirection: "IMPORT",
|
||
maxVgmTons: 26,
|
||
effectiveFrom: base,
|
||
isActive: true,
|
||
},
|
||
{
|
||
containerTypeId: twenty.id,
|
||
tradeDirection: "EXPORT",
|
||
maxVgmTons: 26,
|
||
effectiveFrom: base,
|
||
isActive: true,
|
||
},
|
||
{
|
||
containerTypeId: forty.id,
|
||
tradeDirection: "IMPORT",
|
||
maxVgmTons: 28,
|
||
effectiveFrom: base,
|
||
isActive: true,
|
||
},
|
||
{
|
||
containerTypeId: forty.id,
|
||
tradeDirection: "EXPORT",
|
||
maxVgmTons: 28,
|
||
effectiveFrom: base,
|
||
isActive: true,
|
||
},
|
||
];
|
||
|
||
for (const rule of rules) {
|
||
const existing = await wlRepo.findOne({
|
||
where: {
|
||
containerTypeId: rule.containerTypeId,
|
||
tradeDirection: rule.tradeDirection,
|
||
},
|
||
});
|
||
|
||
if (existing) {
|
||
await wlRepo.update(existing.id, {
|
||
maxVgmTons: rule.maxVgmTons,
|
||
effectiveFrom: rule.effectiveFrom,
|
||
});
|
||
} else {
|
||
await wlRepo.insert(rule);
|
||
}
|
||
}
|
||
|
||
this.logger.log("Seeded weight limit rules");
|
||
}
|
||
private async seedPriorityConfigs(prRepo: any): Promise<void> {
|
||
// Wagon Count Block — independent, applies regardless of currency.
|
||
// Currency Block — applies only to the matching payment currency, within the wagon range.
|
||
// Both blocks are additive (see RuleEngineService.evaluate).
|
||
const rows = [
|
||
// ── Wagon Count Block ───────────────────────────────────────────────
|
||
{ type: "WAGON", label: "Wagons 1–20", currency: null, minWagonCount: 1, maxWagonCount: 20, scorePoints: 0, displayOrder: 1 },
|
||
{ type: "WAGON", label: "Wagons 21–30", currency: null, minWagonCount: 21, maxWagonCount: 30, scorePoints: 15, displayOrder: 2 },
|
||
{ type: "WAGON", label: "Wagons 31–40", currency: null, minWagonCount: 31, maxWagonCount: 40, scorePoints: 30, displayOrder: 3 },
|
||
{ type: "WAGON", label: "Wagons 41–50", currency: null, minWagonCount: 41, maxWagonCount: 50, scorePoints: 50, displayOrder: 4 },
|
||
// ── Payment Currency Block ──────────────────────────────────────────
|
||
{ type: "CURRENCY", label: "USD · Wagons 1–25", currency: "USD", minWagonCount: 1, maxWagonCount: 25, scorePoints: 17, displayOrder: 5 },
|
||
{ type: "CURRENCY", label: "USD · Wagons 26–50", currency: "USD", minWagonCount: 26, maxWagonCount: 50, scorePoints: 35, displayOrder: 6 },
|
||
{ type: "CURRENCY", label: "ETB · Wagons 1–50", currency: "ETB", minWagonCount: 1, maxWagonCount: 50, scorePoints: 0, displayOrder: 7 },
|
||
];
|
||
|
||
for (const row of rows) {
|
||
const existing = await prRepo.findOne({
|
||
where: { type: row.type, label: row.label },
|
||
withDeleted: true,
|
||
});
|
||
if (existing) {
|
||
await prRepo.save({ ...existing, ...row, isActive: true, deletedAt: null });
|
||
} else {
|
||
await prRepo.save(prRepo.create({ ...row, isActive: true }));
|
||
}
|
||
}
|
||
this.logger.log("Seeded priority configs");
|
||
}
|
||
|
||
private async seedRates(
|
||
rRepo: any,
|
||
ctByCode: Map<string, any>,
|
||
): Promise<Rate[]> {
|
||
const effectiveFrom = new Date("2026-01-01");
|
||
const now = new Date();
|
||
// await rRepo.createQueryBuilder().delete().execute();
|
||
|
||
const rateData = [
|
||
{
|
||
rateType: "CONTAINER_IMPORT",
|
||
containerTypeId: ctByCode.get("20FT")!.id,
|
||
currency: "USD",
|
||
rateValue: 800,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "CONTAINER_IMPORT",
|
||
containerTypeId: ctByCode.get("40FT")!.id,
|
||
currency: "USD",
|
||
rateValue: 1200,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "CONTAINER_EXPORT",
|
||
containerTypeId: ctByCode.get("20FT")!.id,
|
||
currency: "USD",
|
||
rateValue: 600,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "CONTAINER_EXPORT",
|
||
containerTypeId: ctByCode.get("40FT")!.id,
|
||
currency: "USD",
|
||
rateValue: 900,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "CONTAINER_IMPORT",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 1000,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "CONTAINER_EXPORT",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 750,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "INTERCITY_CONTAINER",
|
||
containerTypeId: ctByCode.get("20FT")!.id,
|
||
currency: "USD",
|
||
rateValue: 350,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "INTERCITY_CONTAINER",
|
||
containerTypeId: ctByCode.get("40FT")!.id,
|
||
currency: "USD",
|
||
rateValue: 550,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "INTERCITY_CONTAINER",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 400,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "INTERCITY_BULK",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 35,
|
||
rateUnit: "PER_TON",
|
||
},
|
||
{
|
||
rateType: "BULK_IMPORT",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 50,
|
||
rateUnit: "PER_TON",
|
||
},
|
||
{
|
||
rateType: "BULK_EXPORT",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 40,
|
||
rateUnit: "PER_TON",
|
||
},
|
||
{
|
||
rateType: "OVERWEIGHT_PER_TON",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 25,
|
||
rateUnit: "PER_TON",
|
||
},
|
||
{
|
||
rateType: "HAZARD_SURCHARGE",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 150,
|
||
rateUnit: "FLAT",
|
||
},
|
||
{
|
||
rateType: "REEFER_SURCHARGE",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 200,
|
||
rateUnit: "FLAT",
|
||
},
|
||
{
|
||
rateType: "DOUBLE_HANDLING",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 100,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
{
|
||
rateType: "LASHING",
|
||
containerTypeId: null,
|
||
currency: "USD",
|
||
rateValue: 50,
|
||
rateUnit: "PER_CONTAINER",
|
||
},
|
||
];
|
||
|
||
const entities = rateData.map((d) =>
|
||
rRepo.create({
|
||
...d,
|
||
status: "LIVE",
|
||
proposedByStaffId: STAFF_USER_ID,
|
||
approvedByCeoId: CEO_USER_ID,
|
||
approvedAt: now,
|
||
effectiveFrom,
|
||
}),
|
||
);
|
||
return rRepo.save(entities);
|
||
}
|
||
|
||
private async seedSurchargeTypes(
|
||
manager: any,
|
||
ratesByType: Map<string, Rate[]>,
|
||
): Promise<void> {
|
||
const surRepo = manager.getRepository(SurchargeType);
|
||
const bcmRepo = manager.getRepository(BookingCargoModifier);
|
||
await bcmRepo.createQueryBuilder().delete().execute();
|
||
const findRate = (rateType: string, currency: string) => {
|
||
const key = `${rateType}|${currency}|`;
|
||
const rates = ratesByType.get(key);
|
||
return rates?.[0];
|
||
};
|
||
|
||
const hazardRateUsd = findRate("HAZARD_SURCHARGE", "USD");
|
||
const reeferRateUsd = findRate("REEFER_SURCHARGE", "USD");
|
||
const overweightRateUsd = findRate("OVERWEIGHT_PER_TON", "USD");
|
||
const shipLineRateUsd = findRate("DOUBLE_HANDLING", "USD");
|
||
const consolidRateUsd = findRate("LASHING", "USD");
|
||
|
||
await surRepo.createQueryBuilder().delete().execute();
|
||
await surRepo.save([
|
||
surRepo.create({
|
||
code: "HAZARDOUS_CARGO",
|
||
label: "Hazardous Cargo",
|
||
triggerCondition: "CARGO_FLAG_HAZARDOUS",
|
||
rateId: hazardRateUsd?.id,
|
||
isActive: true,
|
||
}),
|
||
surRepo.create({
|
||
code: "REEFER_CARGO",
|
||
label: "Reefer Cargo",
|
||
triggerCondition: "CARGO_FLAG_REEFER",
|
||
rateId: reeferRateUsd?.id,
|
||
isActive: true,
|
||
}),
|
||
surRepo.create({
|
||
code: "OVERWEIGHT_CARGO",
|
||
label: "Overweight Cargo",
|
||
triggerCondition: "VGM_EXCEEDS_LIMIT",
|
||
rateId: overweightRateUsd?.id,
|
||
isActive: true,
|
||
}),
|
||
surRepo.create({
|
||
code: "SHIPPING_LINE_FEE",
|
||
label: "Shipping Line Fee",
|
||
triggerCondition: "SHIPPING_LINE_MAPPED",
|
||
rateId: shipLineRateUsd?.id,
|
||
isActive: true,
|
||
}),
|
||
surRepo.create({
|
||
code: "CONSOLIDATION_FEE",
|
||
label: "Consolidation Fee",
|
||
triggerCondition: "CONSOLIDATION_ENABLED",
|
||
rateId: consolidRateUsd?.id,
|
||
isActive: true,
|
||
}),
|
||
]);
|
||
this.logger.log("Seeded surcharge types");
|
||
}
|
||
|
||
private async seedDraftBookings(
|
||
ctByCode: Map<string, any>,
|
||
yardByCode: Map<string, any>,
|
||
stByCode: Map<string, any>,
|
||
slByCode: Map<string, any>,
|
||
cargoByCode: Map<string, any>,
|
||
): Promise<void> {
|
||
const djibouti = yardByCode.get("DJIBOUTI")!;
|
||
const addis = yardByCode.get("ADDIS_ABABA")!;
|
||
const railContainer = stByCode.get("RAIL_CONTAINER")!;
|
||
const railBulk = stByCode.get("RAIL_BULK")!;
|
||
const maersk = slByCode.get("MAERSK")!;
|
||
const grain = cargoByCode.get("GRAIN")!;
|
||
const twenty = ctByCode.get("20FT")!;
|
||
const forty = ctByCode.get("40FT")!;
|
||
const twentyReefer = ctByCode.get("20FT_REEFER")!;
|
||
|
||
const drafts = [
|
||
{
|
||
reference: "BKG-PRICE-001",
|
||
description: "Standard 20FT container import — base rail only",
|
||
freightType: "CONTAINER" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railContainer.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: false,
|
||
allowConsolidation: false,
|
||
shippingLineId: null,
|
||
cargoTypeId: null,
|
||
cargoTotalWeightVgm: 250,
|
||
containers: [
|
||
{ containerTypeId: twenty.id, quantity: 10, vgmPerUnitTons: 25 },
|
||
],
|
||
expectedBaseRate: 800,
|
||
expectedSurcharges: [],
|
||
},
|
||
{
|
||
reference: "BKG-PRICE-002",
|
||
description: "40FT container import + hazardous surcharge",
|
||
freightType: "CONTAINER" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railContainer.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: true,
|
||
allowConsolidation: false,
|
||
shippingLineId: null,
|
||
cargoTypeId: null,
|
||
cargoTotalWeightVgm: 135,
|
||
containers: [
|
||
{ containerTypeId: forty.id, quantity: 5, vgmPerUnitTons: 27 },
|
||
],
|
||
expectedBaseRate: 1200,
|
||
expectedSurcharges: ["HAZARDOUS_CARGO"],
|
||
},
|
||
{
|
||
reference: "BKG-PRICE-003",
|
||
description: "20FT container import + shipping line (USD)",
|
||
freightType: "CONTAINER" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railContainer.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: false,
|
||
allowConsolidation: false,
|
||
shippingLineId: maersk.id,
|
||
cargoTypeId: null,
|
||
cargoTotalWeightVgm: 480,
|
||
containers: [
|
||
{ containerTypeId: twenty.id, quantity: 20, vgmPerUnitTons: 24 },
|
||
],
|
||
expectedBaseRate: 800,
|
||
expectedSurcharges: ["SHIPPING_LINE_FEE"],
|
||
},
|
||
{
|
||
reference: "BKG-PRICE-004",
|
||
description: "40FT container import + consolidation (USD)",
|
||
freightType: "CONTAINER" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railContainer.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: false,
|
||
allowConsolidation: true,
|
||
shippingLineId: null,
|
||
cargoTypeId: null,
|
||
cargoTotalWeightVgm: 224,
|
||
containers: [
|
||
{ containerTypeId: forty.id, quantity: 8, vgmPerUnitTons: 28 },
|
||
],
|
||
expectedBaseRate: 1200,
|
||
expectedSurcharges: ["CONSOLIDATION_FEE"],
|
||
},
|
||
{
|
||
reference: "BKG-PRICE-005",
|
||
description: "Bulk import — grain",
|
||
freightType: "BULK" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railBulk.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: false,
|
||
allowConsolidation: false,
|
||
shippingLineId: null,
|
||
cargoTypeId: grain.id,
|
||
cargoTotalWeightVgm: 500,
|
||
containers: [],
|
||
expectedBaseRate: 50,
|
||
expectedSurcharges: [],
|
||
},
|
||
{
|
||
reference: "BKG-PRICE-006",
|
||
description: "20FT reefer container import + reefer surcharge",
|
||
freightType: "CONTAINER" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railContainer.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: false,
|
||
allowConsolidation: false,
|
||
shippingLineId: null,
|
||
cargoTypeId: null,
|
||
cargoTotalWeightVgm: 75,
|
||
containers: [
|
||
{ containerTypeId: twentyReefer.id, quantity: 3, vgmPerUnitTons: 25 },
|
||
],
|
||
expectedBaseRate: 800,
|
||
expectedSurcharges: ["REEFER_CARGO"],
|
||
},
|
||
{
|
||
reference: "BKG-PRICE-007",
|
||
description: "20FT container import + overweight (30t > 26t limit)",
|
||
freightType: "CONTAINER" as const,
|
||
tradeDirection: "IMPORT",
|
||
paymentCurrency: "USD",
|
||
serviceTypeId: railContainer.id,
|
||
originYardId: djibouti.id,
|
||
destinationYardId: addis.id,
|
||
isHazardous: false,
|
||
allowConsolidation: false,
|
||
shippingLineId: null,
|
||
cargoTypeId: null,
|
||
cargoTotalWeightVgm: 300,
|
||
containers: [
|
||
{ containerTypeId: twenty.id, quantity: 10, vgmPerUnitTons: 30 },
|
||
],
|
||
expectedBaseRate: 800,
|
||
expectedSurcharges: ["OVERWEIGHT_CARGO"],
|
||
},
|
||
];
|
||
|
||
this.logger.log(`Seeded ${drafts.length} DRAFT bookings for pricing`);
|
||
}
|
||
}
|