mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-27 00:52:50 +00:00
663 lines
24 KiB
TypeScript
663 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 { 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]));
|
||
|
||
// Clear booking cargo modifiers up front — they reference rate snapshots
|
||
// that get recomputed when bookings are repriced.
|
||
await manager.getRepository(BookingCargoModifier).createQueryBuilder().delete().execute();
|
||
|
||
const cargoTypesForRates = await manager.getRepository(CargoType).find();
|
||
const cargoForRatesByCode = new Map(cargoTypesForRates.map((c) => [c.code, c]));
|
||
await this.seedRates(rRepo, ctByCode, cargoForRatesByCode);
|
||
|
||
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: 15,
|
||
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: 10,
|
||
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",
|
||
showFreeTextBox: false,
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 1,
|
||
},
|
||
{
|
||
code: "FERTILIZER",
|
||
cargoTypeName: "Fertilizer",
|
||
showFreeTextBox: false,
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 2,
|
||
},
|
||
{
|
||
code: "CEMENT",
|
||
cargoTypeName: "Cement / Clinker",
|
||
showFreeTextBox: false,
|
||
requiresDirectorApproval: false,
|
||
isActive: true,
|
||
displayOrder: 3,
|
||
},
|
||
{
|
||
code: "STEEL",
|
||
cargoTypeName: "Steel / Rebar",
|
||
showFreeTextBox: false,
|
||
requiresDirectorApproval: true,
|
||
isActive: true,
|
||
displayOrder: 4,
|
||
},
|
||
{
|
||
code: "MACHINERY",
|
||
cargoTypeName: "Heavy Machinery",
|
||
showFreeTextBox: false,
|
||
requiresDirectorApproval: true,
|
||
isActive: true,
|
||
displayOrder: 5,
|
||
},
|
||
{
|
||
code: "OTHER_BULK",
|
||
cargoTypeName: "Other Bulk Cargo",
|
||
showFreeTextBox: false,
|
||
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> {
|
||
// Priority rule = Wagon Block + Currency Block (both additive; see RuleEngineService.evaluate).
|
||
// Combined with the service-type bonus the total priority score caps at 100:
|
||
// service-type bonus (≤ 15) + wagon block (≤ 50) + currency block (≤ 35) = 100.
|
||
// Wagon Count Block — independent, applies regardless of currency. Max 50.
|
||
// Currency Block — applies only to the matching payment currency, within the wagon range. Max 35.
|
||
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: 15, 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>,
|
||
cargoByCode: Map<string, any>,
|
||
): Promise<Rate[]> {
|
||
const effectiveFrom = new Date("2026-01-01");
|
||
const now = new Date();
|
||
|
||
// Each rate is self-describing: `appliesTo` + `trigger` decide how the
|
||
// engine uses it. trigger=ALWAYS → base freight; anything else → a
|
||
// surcharge that stacks additively when the booking matches.
|
||
const rateData = [
|
||
// ── Container base freight ──────────────────────────────────────────
|
||
{ appliesTo: "CONTAINER", trigger: "ALWAYS", rateType: "CONTAINER_IMPORT", tradeDirection: "IMPORT", containerTypeId: ctByCode.get("20FT")!.id, rateValue: 800, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "CONTAINER", trigger: "ALWAYS", rateType: "CONTAINER_IMPORT", tradeDirection: "IMPORT", containerTypeId: ctByCode.get("40FT")!.id, rateValue: 1200, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "CONTAINER", trigger: "ALWAYS", rateType: "CONTAINER_EXPORT", tradeDirection: "EXPORT", containerTypeId: ctByCode.get("20FT")!.id, rateValue: 600, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "CONTAINER", trigger: "ALWAYS", rateType: "CONTAINER_EXPORT", tradeDirection: "EXPORT", containerTypeId: ctByCode.get("40FT")!.id, rateValue: 900, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "CONTAINER", trigger: "ALWAYS", rateType: "CONTAINER_IMPORT", tradeDirection: "IMPORT", containerTypeId: null, rateValue: 1000, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "CONTAINER", trigger: "ALWAYS", rateType: "CONTAINER_EXPORT", tradeDirection: "EXPORT", containerTypeId: null, rateValue: 750, rateUnit: "PER_CONTAINER" },
|
||
// ── Intercity base freight ──────────────────────────────────────────
|
||
{ appliesTo: "INTERCITY", trigger: "ALWAYS", rateType: "INTERCITY_CONTAINER", containerTypeId: ctByCode.get("20FT")!.id, rateValue: 350, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "INTERCITY", trigger: "ALWAYS", rateType: "INTERCITY_CONTAINER", containerTypeId: ctByCode.get("40FT")!.id, rateValue: 550, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "INTERCITY", trigger: "ALWAYS", rateType: "INTERCITY_CONTAINER", containerTypeId: null, rateValue: 400, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "INTERCITY", trigger: "ALWAYS", rateType: "INTERCITY_BULK", rateValue: 35, rateUnit: "PER_TON" },
|
||
// ── Bulk base freight (by leaf cargo type where known) ──────────────
|
||
{ appliesTo: "BULK", trigger: "ALWAYS", rateType: "BULK_IMPORT", tradeDirection: "IMPORT", cargoTypeId: cargoByCode.get("GRAIN")?.id ?? null, rateValue: 50, rateUnit: "PER_TON" },
|
||
{ appliesTo: "BULK", trigger: "ALWAYS", rateType: "BULK_EXPORT", tradeDirection: "EXPORT", cargoTypeId: cargoByCode.get("GRAIN")?.id ?? null, rateValue: 40, rateUnit: "PER_TON" },
|
||
{ appliesTo: "BULK", trigger: "ALWAYS", rateType: "BULK_IMPORT", tradeDirection: "IMPORT", cargoTypeId: null, rateValue: 50, rateUnit: "PER_TON" },
|
||
{ appliesTo: "BULK", trigger: "ALWAYS", rateType: "BULK_EXPORT", tradeDirection: "EXPORT", cargoTypeId: null, rateValue: 40, rateUnit: "PER_TON" },
|
||
// ── Surcharges (trigger-based) ──────────────────────────────────────
|
||
{ appliesTo: "OTHER", trigger: "OVERWEIGHT", rateType: "OVERWEIGHT_PER_TON", rateValue: 25, rateUnit: "PER_TON" },
|
||
{ appliesTo: "OTHER", trigger: "HAZARDOUS", rateType: "HAZARD_SURCHARGE", rateValue: 150, rateUnit: "FLAT" },
|
||
{ appliesTo: "OTHER", trigger: "REEFER", rateType: "REEFER_SURCHARGE", rateValue: 200, rateUnit: "FLAT" },
|
||
{ appliesTo: "OTHER", trigger: "SHIPPING_LINE", rateType: "DOUBLE_HANDLING", rateValue: 100, rateUnit: "PER_CONTAINER" },
|
||
{ appliesTo: "OTHER", trigger: "CONSOLIDATION", rateType: "LASHING", rateValue: 50, rateUnit: "PER_CONTAINER" },
|
||
];
|
||
|
||
// Idempotent: insert each canonical rate only if no row with the same
|
||
// signature already exists. Re-running the seeder must NOT accumulate
|
||
// duplicate rows — duplicated surcharge rates would otherwise repeat on
|
||
// every booking's price breakdown.
|
||
const signature = (r: {
|
||
rateType: string;
|
||
rateUnit: string;
|
||
rateValue: number;
|
||
currency: string;
|
||
containerTypeId?: string | null;
|
||
cargoTypeId?: string | null;
|
||
}) =>
|
||
[
|
||
r.rateType,
|
||
r.rateUnit,
|
||
Number(r.rateValue),
|
||
r.currency,
|
||
r.containerTypeId ?? "",
|
||
r.cargoTypeId ?? "",
|
||
].join("|");
|
||
|
||
const existing: Rate[] = await rRepo.find();
|
||
const existingBySignature = new Set(existing.map((r) => signature(r)));
|
||
|
||
const toCreate = rateData
|
||
.map((d) => ({
|
||
currency: "USD",
|
||
...d,
|
||
status: "LIVE" as const,
|
||
proposedByStaffId: STAFF_USER_ID,
|
||
approvedByCeoId: CEO_USER_ID,
|
||
approvedAt: now,
|
||
effectiveFrom,
|
||
}))
|
||
.filter((d) => !existingBySignature.has(signature(d)));
|
||
|
||
if (toCreate.length === 0) {
|
||
this.logger.log("Rates already seeded — skipping (idempotent)");
|
||
return existing;
|
||
}
|
||
|
||
const created = await rRepo.save(toCreate.map((d) => rRepo.create(d)));
|
||
this.logger.log(`Seeded ${created.length} new rate(s)`);
|
||
return [...existing, ...created];
|
||
}
|
||
|
||
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 missing: string[] = [];
|
||
if (!djibouti) missing.push("yard:DJIBOUTI");
|
||
if (!addis) missing.push("yard:ADDIS_ABABA");
|
||
if (!railContainer) missing.push("serviceType:RAIL_CONTAINER");
|
||
if (!railBulk) missing.push("serviceType:RAIL_BULK");
|
||
if (!grain) missing.push("cargoType:GRAIN");
|
||
if (!twenty) missing.push("containerType:20FT");
|
||
if (!forty) missing.push("containerType:40FT");
|
||
if (!twentyReefer) missing.push("containerType:20FT_REEFER");
|
||
if (missing.length > 0) {
|
||
this.logger.warn(`seedDraftBookings: skipping — missing reference data: ${missing.join(", ")}`);
|
||
return;
|
||
}
|
||
|
||
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, 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, 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, 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, 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, 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, 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, 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`);
|
||
}
|
||
}
|