257 lines
8.4 KiB
TypeScript
257 lines
8.4 KiB
TypeScript
import type {
|
|
MileageSourceCategory,
|
|
MileageSourceGroup,
|
|
MileageSourceProtocol,
|
|
MonitoringData,
|
|
TargetSummary,
|
|
TargetVehicle,
|
|
TrendPoint,
|
|
} from './types';
|
|
import { fetchJson } from '../../auth/api-client';
|
|
|
|
const BASE = '/api/mileage';
|
|
|
|
export async function fetchMonitoring(params?: {
|
|
sortBy?: string;
|
|
sortOrder?: string;
|
|
limit?: number;
|
|
page?: number;
|
|
search?: string;
|
|
dept?: string;
|
|
customer?: string;
|
|
project?: string;
|
|
entity?: string;
|
|
rentStatus?: string;
|
|
platePrefix?: string;
|
|
targetName?: string;
|
|
targetNames?: string[];
|
|
region?: string;
|
|
plate?: string;
|
|
mileageMin?: string;
|
|
mileageMax?: string;
|
|
date?: string;
|
|
startDate?: string;
|
|
endDate?: string;
|
|
brands?: string[];
|
|
sourcePriority?: MileageSourceGroup[];
|
|
}): Promise<MonitoringData> {
|
|
const query = new URLSearchParams();
|
|
if (params?.sortBy) query.set('sortBy', params.sortBy);
|
|
if (params?.sortOrder) query.set('sortOrder', params.sortOrder);
|
|
if (params?.limit) query.set('limit', String(params.limit));
|
|
if (params?.page) query.set('page', String(params.page));
|
|
if (params?.search) query.set('search', params.search);
|
|
if (params?.dept) query.set('dept', params.dept);
|
|
if (params?.customer) query.set('customer', params.customer);
|
|
if (params?.project) query.set('project', params.project);
|
|
if (params?.entity) query.set('entity', params.entity);
|
|
if (params?.rentStatus) query.set('rentStatus', params.rentStatus);
|
|
if (params?.platePrefix) query.set('platePrefix', params.platePrefix);
|
|
if (params?.targetName) query.set('targetName', params.targetName);
|
|
if (params?.targetNames) {
|
|
params.targetNames.forEach(name => {
|
|
if (name) query.append('targetName', name);
|
|
});
|
|
}
|
|
if (params?.region) query.set('region', params.region);
|
|
if (params?.brands) {
|
|
params.brands.forEach(brand => {
|
|
if (brand) query.append('brand', brand);
|
|
});
|
|
}
|
|
if (params?.plate) query.set('plate', params.plate);
|
|
if (params?.mileageMin) query.set('mileageMin', params.mileageMin);
|
|
if (params?.mileageMax) query.set('mileageMax', params.mileageMax);
|
|
if (params?.date) query.set('date', params.date);
|
|
if (params?.startDate) query.set('startDate', params.startDate);
|
|
if (params?.endDate) query.set('endDate', params.endDate);
|
|
if (params?.sourcePriority?.length) query.set('sourcePriority', params.sourcePriority.join(','));
|
|
const qs = query.toString();
|
|
return fetchJson<MonitoringData>(`${BASE}/monitoring${qs ? `?${qs}` : ''}`);
|
|
}
|
|
|
|
export async function fetchTargets(): Promise<TargetSummary[]> {
|
|
return fetchJson<TargetSummary[]>(`${BASE}/targets`);
|
|
}
|
|
|
|
export async function fetchTargetVehicles(targetId: number, date?: string): Promise<TargetVehicle[]> {
|
|
const params = new URLSearchParams();
|
|
if (date) params.set('date', date);
|
|
const qs = params.toString();
|
|
return fetchJson<TargetVehicle[]>(`${BASE}/target/${targetId}/vehicles${qs ? `?${qs}` : ''}`);
|
|
}
|
|
|
|
export async function fetchTrend(targetId?: number, days = 7): Promise<TrendPoint[]> {
|
|
const params = new URLSearchParams();
|
|
if (targetId) params.set('targetId', String(targetId));
|
|
params.set('days', String(days));
|
|
return fetchJson<TrendPoint[]>(`${BASE}/trend?${params.toString()}`);
|
|
}
|
|
|
|
export interface VehicleRecentDay {
|
|
date: string;
|
|
dailyKm: number;
|
|
isDataSynced: boolean;
|
|
sourceProtocol: MileageSourceProtocol | null;
|
|
sourceCategory: Exclude<MileageSourceCategory, 'MIXED'> | null;
|
|
}
|
|
|
|
export interface VehicleRecentResponse {
|
|
plate: string;
|
|
start?: string;
|
|
end?: string;
|
|
days: VehicleRecentDay[];
|
|
sourcePriority?: MileageSourceGroup[];
|
|
}
|
|
|
|
export async function fetchVehicleRecent(
|
|
plate: string,
|
|
range: {
|
|
days?: number;
|
|
start?: string;
|
|
end?: string;
|
|
sourcePriority?: MileageSourceGroup[];
|
|
} = { days: 15 },
|
|
): Promise<VehicleRecentResponse> {
|
|
const params = new URLSearchParams();
|
|
if (range.start) params.set('start', range.start);
|
|
if (range.end) params.set('end', range.end);
|
|
if (range.days != null) params.set('days', String(range.days));
|
|
if (range.sourcePriority?.length) params.set('sourcePriority', range.sourcePriority.join(','));
|
|
return fetchJson<VehicleRecentResponse>(
|
|
`${BASE}/vehicle/${encodeURIComponent(plate)}/recent?${params.toString()}`
|
|
);
|
|
}
|
|
|
|
export interface DailyReportModel {
|
|
id: number;
|
|
name: string;
|
|
count: number;
|
|
today: number;
|
|
total: number;
|
|
completion: number;
|
|
active: number;
|
|
zero: number;
|
|
dailyNeed: number;
|
|
}
|
|
|
|
export interface DailyReportVehicle {
|
|
plate: string;
|
|
model: string;
|
|
status: string;
|
|
customer: string;
|
|
today?: number;
|
|
completion?: number;
|
|
}
|
|
|
|
export interface DailyReportData {
|
|
reportDate: string;
|
|
updatedAt: string;
|
|
models: DailyReportModel[];
|
|
trend: { date: string; value: number }[];
|
|
topVehicles: DailyReportVehicle[];
|
|
zeroRisk: DailyReportVehicle[];
|
|
qualifiedCount: number;
|
|
halfQualifiedCount: number;
|
|
}
|
|
|
|
function reportDateFromUpdatedAt(updatedAt: string): string {
|
|
if (/^\d{4}-\d{2}-\d{2}$/.test(updatedAt)) return updatedAt;
|
|
const d = new Date(updatedAt);
|
|
if (!Number.isNaN(d.getTime())) return d.toISOString().slice(0, 10);
|
|
return new Date().toISOString().slice(0, 10);
|
|
}
|
|
|
|
function compactTargetName(name: string): string {
|
|
return name
|
|
.replace(/^羚牛/, '')
|
|
.replace(/辆/g, '台')
|
|
.replace(/4\.5T普货/g, '普货')
|
|
.replace(/4\.5T冷链车/g, '冷链车')
|
|
.replace(/4\.5T冷链/g, '冷链车');
|
|
}
|
|
|
|
function normalizeStatus(status: string | null): string {
|
|
if (!status) return '未标注';
|
|
if (status === '自营' || status === '租赁') return status;
|
|
if (/租/.test(status)) return '租赁';
|
|
if (/自/.test(status)) return '自营';
|
|
if (/库|Inventory/i.test(status)) return '在库';
|
|
return status;
|
|
}
|
|
|
|
export async function fetchDailyReport(): Promise<DailyReportData> {
|
|
const [targets, trend, monitoring, topMonitoring] = await Promise.all([
|
|
fetchTargets(),
|
|
fetchTrend(undefined, 7),
|
|
fetchMonitoring({ limit: 1 }),
|
|
fetchMonitoring({ sortBy: 'today', sortOrder: 'desc', limit: 5 }),
|
|
]);
|
|
|
|
const targetVehiclesEntries = await Promise.all(
|
|
targets.map(async target => {
|
|
const vehicles = await fetchTargetVehicles(target.id);
|
|
return [target.id, vehicles] as const;
|
|
}),
|
|
);
|
|
const targetVehiclesMap = new Map(targetVehiclesEntries);
|
|
|
|
const models: DailyReportModel[] = targets.map(target => {
|
|
const vehicles = targetVehiclesMap.get(target.id) ?? [];
|
|
const active = vehicles.filter(vehicle => vehicle.todayMileage > 0).length;
|
|
return {
|
|
id: target.id,
|
|
name: compactTargetName(target.targetName),
|
|
count: target.vehicleCount,
|
|
today: target.todayTotal,
|
|
total: target.cumulativeTotal,
|
|
completion: target.avgCompletion,
|
|
active,
|
|
zero: Math.max(0, target.vehicleCount - active),
|
|
dailyNeed: target.dailyTarget,
|
|
};
|
|
});
|
|
|
|
const targetNameByPlate = new Map<string, string>();
|
|
for (const target of targets) {
|
|
const vehicles = targetVehiclesMap.get(target.id) ?? [];
|
|
for (const vehicle of vehicles) targetNameByPlate.set(vehicle.plateNumber, compactTargetName(target.targetName));
|
|
}
|
|
|
|
const topVehicles: DailyReportVehicle[] = topMonitoring.vehicles.map(vehicle => ({
|
|
plate: vehicle.plate,
|
|
model: targetNameByPlate.get(vehicle.plate) || vehicle.project || '未归入考核',
|
|
status: normalizeStatus(vehicle.rentStatus),
|
|
today: vehicle.dailyKm,
|
|
customer: vehicle.customer || '未绑定客户',
|
|
}));
|
|
|
|
const zeroRisk = targetVehiclesEntries
|
|
.flatMap(([targetId, vehicles]) => {
|
|
const target = targets.find(item => item.id === targetId);
|
|
const model = target ? compactTargetName(target.targetName) : '未归入考核';
|
|
return vehicles
|
|
.filter(vehicle => vehicle.todayMileage <= 0 && ['自营', '租赁'].includes(normalizeStatus(vehicle.rentStatus)))
|
|
.map(vehicle => ({
|
|
plate: vehicle.plateNumber,
|
|
model,
|
|
status: normalizeStatus(vehicle.rentStatus),
|
|
customer: vehicle.customer || '未绑定客户',
|
|
completion: vehicle.completionRate,
|
|
}));
|
|
})
|
|
.sort((a, b) => (b.completion ?? 0) - (a.completion ?? 0))
|
|
.slice(0, 5);
|
|
|
|
return {
|
|
reportDate: reportDateFromUpdatedAt(monitoring.updatedAt),
|
|
updatedAt: monitoring.updatedAt,
|
|
models,
|
|
trend: trend.map(item => ({ date: item.date, value: item.mileage })),
|
|
topVehicles,
|
|
zeroRisk,
|
|
qualifiedCount: targets.reduce((sum, target) => sum + target.yearQualifiedCount, 0),
|
|
halfQualifiedCount: targets.reduce((sum, target) => sum + target.halfQualifiedCount, 0),
|
|
};
|
|
}
|