mirror of
https://github.com/Tria-plc/edr-platform.git
synced 2026-08-29 21:08:12 +00:00
553 lines
20 KiB
TypeScript
553 lines
20 KiB
TypeScript
import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
|
|
import { DataSource, FindOptionsWhere, In, IsNull, Not } from 'typeorm';
|
|
|
|
import { BookingsRepository } from '../bookings/bookings.repository';
|
|
import { DriversService } from '../drivers/drivers.service';
|
|
import { SmsClientService } from '../notifications/sms-client.service';
|
|
import { VehiclesService } from '../vehicles/vehicles.service';
|
|
import { VehicleAvailability } from '../vehicles/entities/vehicle.entity';
|
|
import { CreateLastMileDto } from './dto/create-last-mile.dto';
|
|
import { UpdateLastMileDto } from './dto/update-last-mile.dto';
|
|
import { LastMile, LastMileStatus } from './entities/last-mile.entity';
|
|
import { LastMileContainerAllocation } from './entities/last-mile-container-allocation.entity';
|
|
import { LastMileVehicleAssignment } from './entities/last-mile-vehicle-assignment.entity';
|
|
import { LastMileRepository } from './last-mile.repository';
|
|
import { InvoiceEventPayload } from '../billing/billing.service';
|
|
import { OnEvent } from '@nestjs/event-emitter';
|
|
import { FleetHistoryService } from '../fleet-history/fleet-history.service';
|
|
import { FleetEventType } from '../fleet-history/entities/fleet-event.entity';
|
|
|
|
type LastMileListFilter = {
|
|
status?: LastMileStatus;
|
|
bookingId?: string;
|
|
vehicleId?: string;
|
|
page?: number;
|
|
pageSize?: number;
|
|
sortBy?: string;
|
|
sortOrder?: string;
|
|
};
|
|
|
|
const SORTABLE_FIELDS: (keyof LastMile)[] = [
|
|
'status',
|
|
'advancedPayment',
|
|
'remainingPayment',
|
|
'createdAt',
|
|
];
|
|
|
|
@Injectable()
|
|
export class LastMileService {
|
|
private readonly logger = new Logger(LastMileService.name);
|
|
|
|
constructor(
|
|
private readonly lastMileRepository: LastMileRepository,
|
|
private readonly bookingsRepository: BookingsRepository,
|
|
private readonly vehiclesService: VehiclesService,
|
|
private readonly driversService: DriversService,
|
|
private readonly smsClient: SmsClientService,
|
|
private readonly dataSource: DataSource,
|
|
private readonly history: FleetHistoryService,
|
|
) {}
|
|
|
|
/** Resolve a vehicle's driver + human labels, for stamping mile events onto
|
|
* the driver's timeline and naming the vehicle. Best-effort — never throws. */
|
|
private async vehicleInfo(
|
|
vehicleId?: string | null,
|
|
): Promise<{ driverId: string | null; plate: string | null; driverName: string | null }> {
|
|
if (!vehicleId) return { driverId: null, plate: null, driverName: null };
|
|
try {
|
|
const v = await this.vehiclesService.findById(vehicleId);
|
|
return {
|
|
driverId: v.assignedDriverId ?? null,
|
|
plate: v.plateNumber ?? v.code ?? null,
|
|
driverName: v.assignedDriverName ?? null,
|
|
};
|
|
} catch {
|
|
return { driverId: null, plate: null, driverName: null };
|
|
}
|
|
}
|
|
|
|
/** A leg counts as having a vehicle if it has a direct assignment or at least
|
|
* one container allocation carrying a vehicle. Gates the IN_TRANSIT move. */
|
|
private async hasAssignedVehicle(
|
|
recordId: string,
|
|
directVehicleId?: string | null,
|
|
): Promise<boolean> {
|
|
if (directVehicleId) return true;
|
|
const count = await this.dataSource.manager.count(LastMileContainerAllocation, {
|
|
where: { lastMileId: recordId, vehicleId: Not(IsNull()) },
|
|
});
|
|
return count > 0;
|
|
}
|
|
|
|
/** Human booking reference for a last-mile record, for the history timeline.
|
|
* Uses the already-loaded relation when present, else looks it up. */
|
|
private async resolveBookingRef(
|
|
record: LastMile,
|
|
): Promise<string | null> {
|
|
const loaded = (record as LastMile & { booking?: { reference?: string } })
|
|
.booking?.reference;
|
|
if (loaded) return loaded;
|
|
if (!record.bookingId) return null;
|
|
try {
|
|
const booking = await this.bookingsRepository.findById(record.bookingId);
|
|
return (booking as { reference?: string } | null)?.reference ?? null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async acceptBooking(bookingReference: string): Promise<LastMile | null> {
|
|
const booking = await this.bookingsRepository.findByReference(bookingReference);
|
|
|
|
if (!booking) {
|
|
return null;
|
|
}
|
|
|
|
if (booking.paymentStatus !== 'PAID') {
|
|
return null;
|
|
}
|
|
|
|
return this.create({
|
|
bookingId: booking.id,
|
|
advancedPayment: 0,
|
|
});
|
|
}
|
|
|
|
async acceptBookingByReference(bookingReference: string): Promise<LastMile | null> {
|
|
const booking = await this.bookingsRepository.findByReference(bookingReference);
|
|
|
|
if (!booking) {
|
|
return null;
|
|
}
|
|
|
|
if (booking.paymentStatus !== 'PAID') {
|
|
return null;
|
|
}
|
|
|
|
|
|
return this.create({
|
|
bookingId: booking.id,
|
|
advancedPayment: 0,
|
|
});
|
|
}
|
|
|
|
async findAll(filter: LastMileListFilter = {}): Promise<{
|
|
data: LastMile[];
|
|
meta: { total: number; page: number; pageSize: number; totalPages: number };
|
|
}> {
|
|
const page = filter.page ?? 1;
|
|
const pageSize = filter.pageSize ?? 50;
|
|
const sortBy = SORTABLE_FIELDS.includes(filter.sortBy as keyof LastMile)
|
|
? (filter.sortBy as keyof LastMile)
|
|
: 'createdAt';
|
|
const sortOrder = filter.sortOrder?.toUpperCase() === 'ASC' ? 'ASC' : 'DESC';
|
|
|
|
const where: FindOptionsWhere<LastMile> = {};
|
|
if (filter.status) where.status = filter.status;
|
|
if (filter.bookingId) where.bookingId = filter.bookingId;
|
|
if (filter.vehicleId) where.vehicleId = filter.vehicleId;
|
|
|
|
const [data, total] = await this.lastMileRepository.findAndCount({
|
|
where,
|
|
relations: {
|
|
booking: { company: true, serviceType: true, originYard: true, destinationYard: true, cargoType: true, bookingContainers: true },
|
|
vehicle: true,
|
|
vehicleAssignments: { vehicle: true },
|
|
},
|
|
order: { [sortBy]: sortOrder },
|
|
skip: (page - 1) * pageSize,
|
|
take: pageSize,
|
|
});
|
|
|
|
return {
|
|
data,
|
|
meta: {
|
|
total,
|
|
page,
|
|
pageSize,
|
|
totalPages: Math.max(1, Math.ceil(total / pageSize)),
|
|
},
|
|
};
|
|
}
|
|
|
|
async findById(id: string): Promise<LastMile> {
|
|
const record = await this.lastMileRepository.findById(id, {
|
|
relations: {
|
|
booking: { company: true, serviceType: true, originYard: true, destinationYard: true, cargoType: true, bookingContainers: true },
|
|
vehicle: true,
|
|
vehicleAssignments: { vehicle: true },
|
|
},
|
|
});
|
|
|
|
if (!record) {
|
|
throw new NotFoundException(`Last-mile record ${id} not found`);
|
|
}
|
|
|
|
return record;
|
|
}
|
|
|
|
async create(dto: CreateLastMileDto): Promise<LastMile> {
|
|
const record = await this.lastMileRepository.create({
|
|
bookingId: dto.bookingId,
|
|
status: dto.status ?? 'READY_TO_TRANSIT',
|
|
advancedPayment: dto.advancedPayment ?? 0,
|
|
remainingPayment: dto.remainingPayment ?? 0,
|
|
estimatedKm: dto.estimatedKm ?? null,
|
|
exactKm: dto.exactKm ?? null,
|
|
vehicleId: dto.vehicleId ?? null,
|
|
paid: (dto as any).paid ?? false,
|
|
});
|
|
|
|
if (dto.vehicleId) {
|
|
await this.vehiclesService.setAvailability(dto.vehicleId, VehicleAvailability.BUSY);
|
|
const info = await this.vehicleInfo(dto.vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
|
|
vehicleId: dto.vehicleId,
|
|
lastMileId: record.id,
|
|
driverId: info.driverId,
|
|
label: record.status,
|
|
metadata: {
|
|
mile: 'LAST',
|
|
bookingRef: await this.resolveBookingRef(record),
|
|
vehiclePlate: info.plate,
|
|
driverName: info.driverName,
|
|
},
|
|
});
|
|
}
|
|
|
|
return record;
|
|
}
|
|
|
|
@OnEvent("lastmile.invoice.paid")
|
|
async onBookingInvoicePaid(payload: InvoiceEventPayload): Promise<void> {
|
|
try {
|
|
await this.lastMileRepository.update(payload.sourceId, { paid: true } as any);
|
|
this.logger.log(`Marked last-mile record ${payload.sourceId} as paid (invoice ${payload.invoiceId})`);
|
|
} catch (err) {
|
|
this.logger.error(
|
|
`Failed to update last-mile payment status for record ${payload.sourceId}: ${String(err)}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
async update(id: string, dto: UpdateLastMileDto): Promise<LastMile> {
|
|
const existing = await this.findById(id);
|
|
|
|
// A leg can only go IN_TRANSIT once a vehicle is assigned (allowing a vehicle
|
|
// assigned in this same request).
|
|
if (dto.status === 'IN_TRANSIT' && existing.status !== 'IN_TRANSIT') {
|
|
const vehicleId =
|
|
dto.vehicleId !== undefined ? dto.vehicleId : existing.vehicleId;
|
|
if (!(await this.hasAssignedVehicle(id, vehicleId))) {
|
|
throw new BadRequestException(
|
|
'Assign a vehicle before marking this last-mile leg in transit',
|
|
);
|
|
}
|
|
}
|
|
|
|
const dtoAny = dto as any;
|
|
const updated = await this.lastMileRepository.update(id, {
|
|
...(dto.bookingId !== undefined ? { bookingId: dto.bookingId } : {}),
|
|
...(dto.status !== undefined ? { status: dto.status } : {}),
|
|
...(dto.advancedPayment !== undefined ? { advancedPayment: dto.advancedPayment } : {}),
|
|
...(dto.remainingPayment !== undefined ? { remainingPayment: dto.remainingPayment } : {}),
|
|
...(dto.estimatedKm !== undefined ? { estimatedKm: dto.estimatedKm } : {}),
|
|
...(dto.exactKm !== undefined ? { exactKm: dto.exactKm } : {}),
|
|
...(dto.vehicleId !== undefined ? { vehicleId: dto.vehicleId } : {}),
|
|
...(dtoAny.paid !== undefined ? { paid: dtoAny.paid } : {}),
|
|
} as any);
|
|
|
|
if (!updated) {
|
|
throw new NotFoundException(`Last-mile record ${id} not found`);
|
|
}
|
|
|
|
// Notify assigned driver on every explicit vehicle assignment or reassignment
|
|
if (dto.vehicleId) {
|
|
void this.notifyDriverAssignment(dto.vehicleId, existing);
|
|
}
|
|
|
|
// Audit the mile↔vehicle (re)assignment on both vehicle and driver lines.
|
|
const bookingRef = await this.resolveBookingRef(existing);
|
|
if (dto.vehicleId !== undefined && dto.vehicleId !== existing.vehicleId) {
|
|
// Keep vehicle availability in sync: new vehicle goes BUSY, replaced one
|
|
// is freed if no other active trip still holds it.
|
|
if (dto.vehicleId) {
|
|
await this.vehiclesService.setAvailability(dto.vehicleId, VehicleAvailability.BUSY);
|
|
}
|
|
if (existing.vehicleId) {
|
|
await this.vehiclesService.releaseIfUnused([existing.vehicleId]);
|
|
}
|
|
if (existing.vehicleId) {
|
|
const info = await this.vehicleInfo(existing.vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_RELEASED,
|
|
vehicleId: existing.vehicleId,
|
|
lastMileId: id,
|
|
driverId: info.driverId,
|
|
metadata: {
|
|
mile: 'LAST',
|
|
bookingRef,
|
|
vehiclePlate: info.plate,
|
|
driverName: info.driverName,
|
|
},
|
|
});
|
|
}
|
|
if (dto.vehicleId) {
|
|
const info = await this.vehicleInfo(dto.vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
|
|
vehicleId: dto.vehicleId,
|
|
lastMileId: id,
|
|
driverId: info.driverId,
|
|
label: updated.status,
|
|
metadata: {
|
|
mile: 'LAST',
|
|
bookingRef,
|
|
vehiclePlate: info.plate,
|
|
driverName: info.driverName,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
if (dto.status !== undefined && dto.status !== existing.status) {
|
|
const vehicleId = updated.vehicleId ?? existing.vehicleId ?? null;
|
|
const info = await this.vehicleInfo(vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_STATUS_CHANGED,
|
|
lastMileId: id,
|
|
vehicleId,
|
|
driverId: info.driverId,
|
|
fromValue: existing.status,
|
|
toValue: dto.status,
|
|
metadata: {
|
|
mile: 'LAST',
|
|
bookingRef,
|
|
vehiclePlate: info.plate,
|
|
driverName: info.driverName,
|
|
},
|
|
});
|
|
}
|
|
|
|
// Delivery finished — free the vehicles this trip was holding.
|
|
if (dto.status === 'DELIVERED' && existing.status !== 'DELIVERED') {
|
|
await this.releaseVehicles(updated);
|
|
}
|
|
|
|
return updated;
|
|
}
|
|
|
|
/**
|
|
* Free every vehicle held by this record (direct assignment + container
|
|
* allocations), unless still in use by another active trip.
|
|
*/
|
|
private async releaseVehicles(record: LastMile): Promise<void> {
|
|
const recordAllocations = await this.dataSource.manager.find(
|
|
LastMileContainerAllocation,
|
|
{ where: { lastMileId: record.id } },
|
|
);
|
|
const vehicleIds = recordAllocations
|
|
.map((a) => a.vehicleId)
|
|
.filter((id): id is string => Boolean(id));
|
|
if (record.vehicleId) {
|
|
vehicleIds.push(record.vehicleId);
|
|
}
|
|
await this.vehiclesService.releaseIfUnused(vehicleIds);
|
|
}
|
|
|
|
/**
|
|
* Replace the full set of vehicles serving a last-mile delivery (multi-truck).
|
|
* Diffs against the current junction rows, syncing availability + audit history
|
|
* for each added/removed vehicle. The first vehicle is mirrored onto the legacy
|
|
* `vehicleId` column for back-compat with single-vehicle readers.
|
|
*/
|
|
async setVehicles(id: string, vehicleIds: string[]): Promise<LastMile> {
|
|
const existing = await this.findById(id);
|
|
const desired = [...new Set(vehicleIds.filter(Boolean))];
|
|
|
|
const manager = this.dataSource.manager;
|
|
const current = await manager.find(LastMileVehicleAssignment, {
|
|
where: { lastMileId: id },
|
|
});
|
|
const currentIds = current.map((a) => a.vehicleId);
|
|
const currentSet = new Set(currentIds);
|
|
const desiredSet = new Set(desired);
|
|
const added = desired.filter((v) => !currentSet.has(v));
|
|
const removed = currentIds.filter((v) => !desiredSet.has(v));
|
|
|
|
await this.dataSource.transaction(async (tx) => {
|
|
if (removed.length) {
|
|
await tx.delete(LastMileVehicleAssignment, {
|
|
lastMileId: id,
|
|
vehicleId: In(removed),
|
|
});
|
|
}
|
|
for (const vehicleId of added) {
|
|
await tx.insert(LastMileVehicleAssignment, { lastMileId: id, vehicleId });
|
|
}
|
|
});
|
|
|
|
// Legacy primary vehicle = first of the set (null when cleared).
|
|
await this.lastMileRepository.update(id, { vehicleId: desired[0] ?? null } as any);
|
|
|
|
const bookingRef = await this.resolveBookingRef(existing);
|
|
for (const vehicleId of added) {
|
|
await this.vehiclesService.setAvailability(vehicleId, VehicleAvailability.BUSY);
|
|
void this.notifyDriverAssignment(vehicleId, existing);
|
|
const info = await this.vehicleInfo(vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
|
|
vehicleId,
|
|
lastMileId: id,
|
|
driverId: info.driverId,
|
|
label: existing.status,
|
|
metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
|
|
});
|
|
}
|
|
for (const vehicleId of removed) {
|
|
await this.vehiclesService.releaseIfUnused([vehicleId]);
|
|
const info = await this.vehicleInfo(vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_RELEASED,
|
|
vehicleId,
|
|
lastMileId: id,
|
|
driverId: info.driverId,
|
|
metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
|
|
});
|
|
}
|
|
|
|
return this.findById(id);
|
|
}
|
|
|
|
private async notifyDriverAssignment(vehicleId: string, record: LastMile): Promise<void> {
|
|
try {
|
|
const vehicle = await this.vehiclesService.findById(vehicleId);
|
|
if (!vehicle.assignedDriverId) {
|
|
this.logger.warn(`Vehicle ${vehicleId} has no assigned driver — skipping SMS`);
|
|
return;
|
|
}
|
|
|
|
const driver = await this.driversService.findById(vehicle.assignedDriverId);
|
|
if (!driver.phoneNumber) {
|
|
this.logger.warn(`Driver ${vehicle.assignedDriverId} has no phone number — skipping SMS`);
|
|
return;
|
|
}
|
|
|
|
type BookingWithYards = {
|
|
reference?: string;
|
|
lastMileDeliveryAddress?: string | null;
|
|
destinationYard?: { label?: string } | null;
|
|
};
|
|
const booking = (record as LastMile & { booking?: BookingWithYards }).booking;
|
|
|
|
const driverName = `${driver.firstName ?? ''} ${driver.lastName ?? ''}`.trim();
|
|
const message =
|
|
`Dear ${driverName}, you have been assigned to a last-mile delivery. ` +
|
|
`Booking: ${booking?.reference ?? record.bookingId}. Vehicle: ${vehicle.plateNumber ?? vehicleId}. ` +
|
|
(booking?.destinationYard?.label ? `Pickup: ${booking.destinationYard.label}. ` : '') +
|
|
(booking?.lastMileDeliveryAddress ? `Destination: ${booking.lastMileDeliveryAddress}.` : '');
|
|
|
|
void this.smsClient.sendSms({
|
|
to: driver.phoneNumber,
|
|
message,
|
|
});
|
|
|
|
this.logger.log(`SMS queued to driver ${driver.phoneNumber} for vehicle ${vehicleId} assignment`);
|
|
} catch (err) {
|
|
this.logger.error(`Failed to notify driver for vehicle ${vehicleId}: ${String(err)}`);
|
|
}
|
|
}
|
|
|
|
async remove(id: string): Promise<void> {
|
|
await this.findById(id);
|
|
await this.lastMileRepository.softDelete(id);
|
|
}
|
|
|
|
async allocateContainers(
|
|
lastMileId: string,
|
|
allocations: Array<{ containerId: string; vehicleId: string }>,
|
|
) {
|
|
const lastMile = await this.findById(lastMileId);
|
|
if (!lastMile) {
|
|
throw new NotFoundException(`Last-mile record ${lastMileId} not found`);
|
|
}
|
|
|
|
// Capture the vehicles currently on these containers so a reallocation can
|
|
// be diffed into assigned/released history events below.
|
|
const previousAllocations = await this.dataSource.manager.find(
|
|
LastMileContainerAllocation,
|
|
{
|
|
where: {
|
|
lastMileId,
|
|
containerId: In(allocations.map((a) => a.containerId)),
|
|
},
|
|
},
|
|
);
|
|
const previousVehicleIds = previousAllocations
|
|
.map((a) => a.vehicleId)
|
|
.filter((id): id is string => Boolean(id));
|
|
|
|
await this.dataSource.transaction(async (manager) => {
|
|
for (const allocation of allocations) {
|
|
await manager.delete(LastMileContainerAllocation, {
|
|
lastMileId,
|
|
containerId: allocation.containerId,
|
|
});
|
|
await manager.insert(LastMileContainerAllocation, {
|
|
lastMileId,
|
|
containerId: allocation.containerId,
|
|
vehicleId: allocation.vehicleId,
|
|
containerType: 'CONTAINER',
|
|
quantity: 1,
|
|
});
|
|
}
|
|
});
|
|
|
|
// Keep vehicle availability in sync: newly-allocated cars go BUSY, cars no
|
|
// longer on any of these containers are freed if unused elsewhere.
|
|
const vehicleIds = new Set(allocations.map((a) => a.vehicleId));
|
|
await Promise.all(
|
|
[...vehicleIds].map((id) =>
|
|
this.vehiclesService.setAvailability(id, VehicleAvailability.BUSY),
|
|
),
|
|
);
|
|
await this.vehiclesService.releaseIfUnused(
|
|
previousVehicleIds.filter((id) => !vehicleIds.has(id)),
|
|
);
|
|
|
|
// History: one event per vehicle actually added or removed by this
|
|
// multi-car (re)allocation, so reassignments show on every timeline.
|
|
const prevSet = new Set(previousVehicleIds);
|
|
const bookingRef = await this.resolveBookingRef(lastMile);
|
|
for (const vehicleId of vehicleIds) {
|
|
if (prevSet.has(vehicleId)) continue;
|
|
const info = await this.vehicleInfo(vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_ASSIGNED,
|
|
vehicleId,
|
|
lastMileId,
|
|
driverId: info.driverId,
|
|
label: lastMile.status,
|
|
metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
|
|
});
|
|
}
|
|
for (const vehicleId of previousVehicleIds) {
|
|
if (vehicleIds.has(vehicleId)) continue;
|
|
const info = await this.vehicleInfo(vehicleId);
|
|
await this.history.record({
|
|
eventType: FleetEventType.MILE_VEHICLE_RELEASED,
|
|
vehicleId,
|
|
lastMileId,
|
|
driverId: info.driverId,
|
|
metadata: { mile: 'LAST', bookingRef, vehiclePlate: info.plate, driverName: info.driverName },
|
|
});
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
allocated: allocations.length,
|
|
};
|
|
}
|
|
}
|