280 lines
9.6 KiB
TypeScript
280 lines
9.6 KiB
TypeScript
import { readFileSync } from 'node:fs';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { dirname, join } from 'node:path';
|
|
import pool from '../../db.js';
|
|
import { fetchVehicleInfoMap } from './vehicle-info.js';
|
|
import { fetchOneOsDailyMileage, fetchOneOsMileageDates } from './oneos-api.js';
|
|
import {
|
|
sourceCategoryFromProtocol,
|
|
type MileageSourceCategory,
|
|
type OneOsProtocol,
|
|
} from './source-policy.js';
|
|
import {
|
|
buildMonitoringFilters,
|
|
buildPlateTargetNamesMap,
|
|
buildTargetPlatesMap,
|
|
dailyMileageMap,
|
|
mergeMonitoringVehicles,
|
|
mileageDatesBetween,
|
|
previousMileageDate,
|
|
toMileageRows,
|
|
type DailyMileageRow,
|
|
type MileageRow,
|
|
type TargetRow,
|
|
} from './cache-model.js';
|
|
import type { CachedVehicle, MonitoringCache, MonitoringFilters } from './types.js';
|
|
|
|
const __dirname = dirname(fileURLToPath(import.meta.url));
|
|
const regionMap: Record<string, string> = JSON.parse(
|
|
readFileSync(join(__dirname, 'region-map.json'), 'utf8')
|
|
);
|
|
let monitoringCache: MonitoringCache | null = null;
|
|
|
|
export function getCache(): MonitoringCache | null {
|
|
return monitoringCache;
|
|
}
|
|
|
|
function shanghaiDate(): string {
|
|
return new Intl.DateTimeFormat('en-CA', {
|
|
timeZone: 'Asia/Shanghai',
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
}).format(new Date());
|
|
}
|
|
|
|
export interface RangeMileageResult {
|
|
vehicles: CachedVehicle[];
|
|
dailyTotals: { date: string; totalKm: number }[];
|
|
start: string;
|
|
end: string;
|
|
}
|
|
|
|
async function fetchTargetRows(): Promise<TargetRow[]> {
|
|
return pool.execute(
|
|
`SELECT t.id, t.target_name, v.plate_number
|
|
FROM lingniu_prod.tab_mileage_assessment_target t
|
|
JOIN lingniu_prod.tab_mileage_assessment_vehicle v ON v.target_id = t.id AND v.is_deleted = 0
|
|
WHERE t.is_deleted = 0`
|
|
).then(([rows]) => rows as TargetRow[]);
|
|
}
|
|
|
|
export async function refreshMonitoringCache(): Promise<void> {
|
|
try {
|
|
console.log('[mileage] refreshing monitoring cache...');
|
|
const start = Date.now();
|
|
|
|
const date = shanghaiDate();
|
|
const [apiRows, yesterdayRows, infoMap, targetRows] = await Promise.all([
|
|
fetchOneOsDailyMileage(date),
|
|
fetchOneOsDailyMileage(previousMileageDate(date)),
|
|
fetchVehicleInfoMap(),
|
|
fetchTargetRows(),
|
|
]);
|
|
|
|
const mileageRows = toMileageRows(apiRows);
|
|
const yesterdayMap = dailyMileageMap(yesterdayRows);
|
|
|
|
const targetPlatesMap = buildTargetPlatesMap(targetRows);
|
|
const targetNamesByPlate = buildPlateTargetNamesMap(targetRows);
|
|
const targetNames = Array.from(targetPlatesMap.keys());
|
|
|
|
const vehicles = mergeMonitoringVehicles(
|
|
mileageRows,
|
|
infoMap,
|
|
yesterdayMap,
|
|
targetNamesByPlate,
|
|
regionMap,
|
|
);
|
|
const totalToday = Math.round(vehicles.reduce((sum, v) => sum + v.dailyKm, 0));
|
|
const totalAll = vehicles.reduce((sum, v) => sum + (v.totalKm || 0), 0);
|
|
|
|
monitoringCache = {
|
|
vehicles,
|
|
stats: { totalToday, totalAll, vehicleCount: vehicles.length },
|
|
filters: buildMonitoringFilters(vehicles, targetNames),
|
|
targetPlatesMap,
|
|
updatedAt: new Date().toISOString(),
|
|
};
|
|
|
|
console.log(`[mileage] cache refreshed: ${vehicles.length} vehicles in ${Date.now() - start}ms`);
|
|
} catch (e: unknown) {
|
|
console.error('[mileage] cache refresh error:', e);
|
|
}
|
|
}
|
|
|
|
export async function queryDateMileage(
|
|
dateStr: string,
|
|
protocolPriority?: OneOsProtocol[],
|
|
): Promise<CachedVehicle[]> {
|
|
const [apiRows, yesterdayRows, infoMap, targetRows] = await Promise.all([
|
|
fetchOneOsDailyMileage(dateStr, undefined, protocolPriority),
|
|
fetchOneOsDailyMileage(previousMileageDate(dateStr), undefined, protocolPriority),
|
|
fetchVehicleInfoMap(),
|
|
fetchTargetRows(),
|
|
]);
|
|
|
|
const mileageRows = toMileageRows(apiRows);
|
|
const yesterdayMap = dailyMileageMap(yesterdayRows);
|
|
|
|
return mergeMonitoringVehicles(
|
|
mileageRows,
|
|
infoMap,
|
|
yesterdayMap,
|
|
buildPlateTargetNamesMap(targetRows),
|
|
regionMap,
|
|
);
|
|
}
|
|
|
|
export async function queryRangeMileage(
|
|
startDate: string,
|
|
endDate: string,
|
|
protocolPriority?: OneOsProtocol[],
|
|
): Promise<RangeMileageResult> {
|
|
if (startDate === endDate) {
|
|
const vehicles = (await queryDateMileage(startDate, protocolPriority)).map(vehicle => ({
|
|
...vehicle,
|
|
dailyMileage: { [startDate]: vehicle.dailyKm },
|
|
dailySourceProtocols: { [startDate]: vehicle.sourceProtocol },
|
|
}));
|
|
return {
|
|
vehicles,
|
|
dailyTotals: [{
|
|
date: startDate,
|
|
totalKm: Math.round(vehicles.reduce((sum, vehicle) => sum + vehicle.dailyKm, 0)),
|
|
}],
|
|
start: startDate,
|
|
end: endDate,
|
|
};
|
|
}
|
|
|
|
const days = mileageDatesBetween(startDate, endDate);
|
|
const [apiRowsByDate, endDateRows, yesterdayRows, infoMap, targetRows] = await Promise.all([
|
|
fetchOneOsMileageDates(days, undefined, protocolPriority),
|
|
fetchOneOsDailyMileage(endDate, undefined, protocolPriority),
|
|
fetchOneOsDailyMileage(previousMileageDate(startDate), undefined, protocolPriority),
|
|
fetchVehicleInfoMap(),
|
|
fetchTargetRows(),
|
|
]);
|
|
const dailyRows: DailyMileageRow[] = [];
|
|
for (const [date, apiRows] of apiRowsByDate) {
|
|
for (const row of apiRows) {
|
|
dailyRows.push({
|
|
plate: row.plateNumber,
|
|
vin: row.vin,
|
|
date,
|
|
daily_km: row.dailyMileageKm,
|
|
source: row.status !== 'NO_DATA' ? 'ONEOS_API' : 'NONE',
|
|
mileage_anomaly: row.status === 'DATA_ANOMALY' ? row.dataQuality || 'DATA_ANOMALY' : null,
|
|
source_protocol: row.sourceProtocol,
|
|
data_time: row.dataTime,
|
|
calculated_at: row.calculatedAt,
|
|
updated_at: row.updatedAt,
|
|
});
|
|
}
|
|
}
|
|
|
|
const perVehicleDaily = new Map<string, Record<string, number>>();
|
|
const perVehicleDailySources = new Map<string, Record<string, OneOsProtocol | null>>();
|
|
const perVehicleSourceCategories = new Map<string, Set<MileageSourceCategory>>();
|
|
const perVehicleSum = new Map<string, MileageRow>();
|
|
const dailyTotals = new Map<string, number>();
|
|
const bestDailyRows = new Map<string, DailyMileageRow>();
|
|
|
|
for (const day of days) dailyTotals.set(day, 0);
|
|
|
|
for (const row of dailyRows) {
|
|
const key = `${row.plate}\u0000${row.date}`;
|
|
const km = Math.max(0, Number(row.daily_km) || 0);
|
|
const existing = bestDailyRows.get(key);
|
|
if (!existing || km > Math.max(0, Number(existing.daily_km) || 0)) {
|
|
bestDailyRows.set(key, row);
|
|
}
|
|
}
|
|
|
|
for (const row of bestDailyRows.values()) {
|
|
const km = Math.max(0, Number(row.daily_km) || 0);
|
|
const date = row.date;
|
|
const plate = row.plate;
|
|
dailyTotals.set(date, (dailyTotals.get(date) || 0) + km);
|
|
|
|
const daily = perVehicleDaily.get(plate) || {};
|
|
daily[date] = km;
|
|
perVehicleDaily.set(plate, daily);
|
|
const dailySources = perVehicleDailySources.get(plate) || {};
|
|
dailySources[date] = row.source_protocol;
|
|
perVehicleDailySources.set(plate, dailySources);
|
|
const category = sourceCategoryFromProtocol(row.source_protocol);
|
|
if (category) {
|
|
const categories = perVehicleSourceCategories.get(plate) || new Set<MileageSourceCategory>();
|
|
categories.add(category);
|
|
perVehicleSourceCategories.set(plate, categories);
|
|
}
|
|
|
|
const existing = perVehicleSum.get(plate);
|
|
perVehicleSum.set(plate, {
|
|
plate,
|
|
vin: existing?.vin || row.vin || '',
|
|
daily_km: String((Number(existing?.daily_km) || 0) + km),
|
|
total_km: null,
|
|
mileage_anomaly: existing?.mileage_anomaly || row.mileage_anomaly || null,
|
|
source: existing?.source !== 'NONE' && existing?.source ? existing.source : (row.source || 'NONE'),
|
|
source_protocol: row.source_protocol || existing?.source_protocol || null,
|
|
data_time: row.data_time || existing?.data_time || null,
|
|
calculated_at: row.calculated_at || existing?.calculated_at || null,
|
|
updated_at: row.updated_at || existing?.updated_at || null,
|
|
});
|
|
}
|
|
|
|
const endDateMap = new Map(endDateRows.map(row => [row.plateNumber, row]));
|
|
for (const [plate, aggregate] of perVehicleSum) {
|
|
const endDateRow = endDateMap.get(plate);
|
|
if (!endDateRow) continue;
|
|
perVehicleSum.set(plate, {
|
|
...aggregate,
|
|
vin: endDateRow.vin || aggregate.vin,
|
|
total_km: endDateRow.totalMileageKm == null ? null : String(endDateRow.totalMileageKm),
|
|
source_protocol: endDateRow.sourceProtocol || aggregate.source_protocol,
|
|
data_time: endDateRow.dataTime || aggregate.data_time,
|
|
updated_at: endDateRow.updatedAt || aggregate.updated_at,
|
|
});
|
|
}
|
|
|
|
const yesterdayMap = dailyMileageMap(yesterdayRows);
|
|
|
|
const vehicles = mergeMonitoringVehicles(
|
|
Array.from(perVehicleSum.values()),
|
|
infoMap,
|
|
yesterdayMap,
|
|
buildPlateTargetNamesMap(targetRows),
|
|
regionMap,
|
|
).map(vehicle => {
|
|
const dailyMileage = perVehicleDaily.get(vehicle.plate) || {};
|
|
const dailySources = perVehicleDailySources.get(vehicle.plate) || {};
|
|
const categories = perVehicleSourceCategories.get(vehicle.plate);
|
|
const completedDailyMileage: Record<string, number> = {};
|
|
const completedDailySources: Record<string, OneOsProtocol | null> = {};
|
|
for (const day of days) completedDailyMileage[day] = dailyMileage[day] || 0;
|
|
for (const day of days) completedDailySources[day] = dailySources[day] || null;
|
|
return {
|
|
...vehicle,
|
|
dailyMileage: completedDailyMileage,
|
|
dailySourceProtocols: completedDailySources,
|
|
sourceCategory: categories && categories.size > 1
|
|
? 'MIXED' as const
|
|
: categories?.values().next().value || vehicle.sourceCategory,
|
|
};
|
|
});
|
|
|
|
return {
|
|
vehicles,
|
|
dailyTotals: days.map(date => ({ date, totalKm: Math.round(dailyTotals.get(date) || 0) })),
|
|
start: startDate,
|
|
end: endDate,
|
|
};
|
|
}
|
|
|
|
export function buildDateFilters(vehicles: CachedVehicle[]): MonitoringFilters {
|
|
return buildMonitoringFilters(vehicles, monitoringCache?.filters.targetNames || []);
|
|
}
|