763 lines
32 KiB
TypeScript
763 lines
32 KiB
TypeScript
import { inventoryKey, inventoryOperation, inventoryColor, emptyInventoryCounts, type InventoryCounts } from '../../shared/assets/inventory.js';
|
||
import { Hono } from 'hono';
|
||
import type {
|
||
Vehicle,
|
||
SummaryData,
|
||
TypeSummary,
|
||
ModelSummary,
|
||
BatchSummary,
|
||
BatchGroup,
|
||
InventoryTypeSummary,
|
||
} from '../types.js';
|
||
import { filterAssetVehiclesByPermission, filterByPermission, maskCustomerNames, maskCustomerName } from '../auth/permissions.js';
|
||
import type { AuthUser } from '../auth/types.js';
|
||
import type { Context } from 'hono';
|
||
import {
|
||
INVENTORY_REGIONS,
|
||
isOperatingVehicle,
|
||
isInventoryVehicle,
|
||
isInventoryAbnormal,
|
||
isInventoryPending,
|
||
SUMMARY_TYPE_FILTERS,
|
||
VEHICLE_TYPE_FILTERS,
|
||
classifyVehicleType,
|
||
compareModelNames,
|
||
filterByLocation,
|
||
mapInventoryRegion,
|
||
mapMacroRegion,
|
||
resolveCity,
|
||
} from './vehicles/model.js';
|
||
import {
|
||
compareDepartmentNames,
|
||
countByType,
|
||
getMileageStats,
|
||
getStats,
|
||
listDateRange,
|
||
normalizeDateRange,
|
||
} from './vehicles/utils.js';
|
||
import { vehicleRepository, type FlowDetailRow, type WeeklyDetailType } from './vehicles/repository.js';
|
||
|
||
import type { AssetAnalysisMetric, AssetAnalysisScope } from '../../shared/assets/analytics.js';
|
||
import {
|
||
abnormalElapsedDays, analysisCellForVehicle, buildAssetAnalysis, loadMovementApprovalTimes,
|
||
matchesAnalysisFilters, matchesAnalysisFilterValues, matchesAnalysisMetric,
|
||
validAnalysisFilters, validAnalysisFilterValues, validAnalysisScope,
|
||
} from './vehicles/analytics.js';
|
||
|
||
export { mapRegion } from './vehicles/model.js';
|
||
|
||
const app = new Hono<{ Variables: { user: AuthUser } }>();
|
||
|
||
async function getVehiclesForUser(c: Context, includePublicInventory = true): Promise<Vehicle[]> {
|
||
const all = await vehicleRepository.getVehicles();
|
||
const user = ((c as any).get?.('user') || (c as any).var?.user) as AuthUser | undefined;
|
||
let list = user ? (includePublicInventory ? filterAssetVehiclesByPermission(all, user) : filterByPermission(all, user)) : all;
|
||
list = applySubjectFilter(c, list);
|
||
return maskCustomerNames(list);
|
||
}
|
||
|
||
// 归属公司筛选（所属公司 = vehicle_info.registered_ownership, 即 Vehicle.subjectOrg）
|
||
function getSubjectParam(c: Context): string | null {
|
||
const raw = (c.req.query('subject') || '').trim();
|
||
return raw ? raw : null;
|
||
}
|
||
|
||
function applySubjectFilter(c: Context, vehicles: Vehicle[]): Vehicle[] {
|
||
const subject = getSubjectParam(c);
|
||
if (!subject) return vehicles;
|
||
return vehicles.filter((v) => (v.subjectOrg || '') === subject);
|
||
}
|
||
|
||
// GET /api/vehicles/summary
|
||
app.get('/summary', async (c) => {
|
||
const [vehicles, weeklyIds] = await Promise.all([getVehiclesForUser(c), vehicleRepository.getWeeklyTruckIds()]);
|
||
const user = c.get('user') as AuthUser | undefined;
|
||
const vehicleIds = new Set((user ? filterByPermission(vehicles, user) : vehicles).map(v => String(v.id)));
|
||
const summary: SummaryData = {
|
||
totalAssets: vehicles.length,
|
||
operating: {
|
||
total: vehicles.filter((v) => isOperatingVehicle(v)).length,
|
||
self: vehicles.filter((v) => ['2', '自营'].includes(v.operationStatus || '')).length,
|
||
leased: vehicles.filter((v) => ['1', '租赁'].includes(v.operationStatus || '')).length,
|
||
public: vehicles.filter((v) => isOperatingVehicle(v) && v.ownership === 'Public').length,
|
||
hanging: 0,
|
||
},
|
||
inventory: {
|
||
total: vehicles.filter((v) => isInventoryVehicle(v)).length,
|
||
inStock: vehicles.filter((v) => isInventoryVehicle(v) && v.status === 'Inventory').length,
|
||
abnormal: vehicles.filter((v) => isInventoryAbnormal(v)).length,
|
||
},
|
||
pendingDelivery: vehicles.filter((v) => isInventoryPending(v)).length,
|
||
weeklyNew: 0,
|
||
weeklyRemoved: 0,
|
||
weeklyDelivered: [...weeklyIds.delivered].filter(id => vehicleIds.has(id)).length,
|
||
weeklyReturned: [...weeklyIds.returned].filter(id => vehicleIds.has(id)).length,
|
||
weeklyReplaced: [...weeklyIds.replaced].filter(id => vehicleIds.has(id)).length,
|
||
};
|
||
return c.json(summary);
|
||
});
|
||
|
||
// GET /api/vehicles/by-type
|
||
app.get('/by-type', async (c) => {
|
||
const [vehicles, allWeeklyIds] = await Promise.all([getVehiclesForUser(c), vehicleRepository.getWeeklyTruckIds()]);
|
||
const user = c.get('user') as AuthUser | undefined;
|
||
const historyIds = new Set((user ? filterByPermission(vehicles, user) : vehicles).map(v => String(v.id)));
|
||
const weeklyIds = {
|
||
...allWeeklyIds,
|
||
delivered: new Set([...allWeeklyIds.delivered].filter(id => historyIds.has(id))),
|
||
returned: new Set([...allWeeklyIds.returned].filter(id => historyIds.has(id))),
|
||
replaced: new Set([...allWeeklyIds.replaced].filter(id => historyIds.has(id))),
|
||
};
|
||
|
||
const result: TypeSummary[] = SUMMARY_TYPE_FILTERS.map((t) => {
|
||
const typeVehicles = vehicles.filter(t.filter);
|
||
const models = Array.from(new Set(typeVehicles.map((v) => v.model)));
|
||
|
||
const modelSummaries: ModelSummary[] = models.map((model) => {
|
||
const modelVehicles = typeVehicles.filter((v) => v.model === model);
|
||
const batches = Array.from(new Set(modelVehicles.map((v) => v.contractNo || '未知'))).filter(Boolean);
|
||
|
||
return {
|
||
model,
|
||
...getStats(modelVehicles, weeklyIds),
|
||
batches: batches.map((batch) => ({
|
||
batch,
|
||
...getStats(modelVehicles.filter((v) => (v.contractNo || '未知') === batch), weeklyIds),
|
||
})),
|
||
};
|
||
});
|
||
|
||
const typeStats = getStats(typeVehicles, weeklyIds);
|
||
return {
|
||
type: t.name,
|
||
totalAssets: typeVehicles.length,
|
||
totalInventory: typeStats.inventory,
|
||
totalAbnormal: typeStats.abnormal,
|
||
totalOperating: typeStats.operating,
|
||
inventoryRegions: typeStats.inventoryRegions,
|
||
pending: typeStats.pending,
|
||
weeklyDelivered: typeStats.weeklyDelivered,
|
||
weeklyReturned: typeStats.weeklyReturned,
|
||
weeklyReplaced: typeStats.weeklyReplaced,
|
||
models: modelSummaries.sort((a, b) => compareModelNames(a.model, b.model)),
|
||
};
|
||
});
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
// GET /api/vehicles/by-batch
|
||
app.get('/by-batch', async (c) => {
|
||
const vehicles = await getVehiclesForUser(c);
|
||
const batches = Array.from(new Set(vehicles.map((v) => v.contractNo || '未知')))
|
||
.filter(Boolean)
|
||
.sort()
|
||
.reverse();
|
||
|
||
const result: BatchGroup[] = batches.map((batch) => {
|
||
const batchVehicles = vehicles.filter((v) => (v.contractNo || '未知') === batch);
|
||
const models = Array.from(new Set(batchVehicles.map((v) => v.model)));
|
||
|
||
return {
|
||
batch,
|
||
...getStats(batchVehicles),
|
||
models: models.map((model) => {
|
||
const modelVehicles = batchVehicles.filter((v) => v.model === model);
|
||
return {
|
||
model,
|
||
type: modelVehicles[0]?.type || '',
|
||
...getStats(modelVehicles),
|
||
};
|
||
}),
|
||
};
|
||
});
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
// GET /api/vehicles/inventory-analysis — 库存分析，不设数据权限，对所有人开放
|
||
app.get('/inventory-analysis', async (c) => {
|
||
const vehicles = applySubjectFilter(c, await vehicleRepository.getVehicles());
|
||
|
||
const result: InventoryTypeSummary[] = SUMMARY_TYPE_FILTERS.map((t) => {
|
||
const typeVehicles = vehicles.filter(t.filter);
|
||
const models = Array.from(new Set(typeVehicles.map((v) => v.model)));
|
||
|
||
const modelData = models.map((model) => {
|
||
const modelVehicles = typeVehicles.filter((v) => v.model === model);
|
||
const inventoryVehicles = modelVehicles.filter((v) => isInventoryVehicle(v));
|
||
|
||
return {
|
||
model,
|
||
totalAssets: modelVehicles.length,
|
||
totalInventory: inventoryVehicles.length,
|
||
regions: INVENTORY_REGIONS.reduce(
|
||
(acc, reg) => {
|
||
acc[reg] = inventoryVehicles.filter((v) => mapInventoryRegion(v.location) === reg).length;
|
||
return acc;
|
||
},
|
||
{} as Record<string, number>,
|
||
),
|
||
};
|
||
});
|
||
|
||
const typeInventory = typeVehicles.filter((v) => isInventoryVehicle(v));
|
||
|
||
return {
|
||
type: t.name,
|
||
totalAssets: typeVehicles.length,
|
||
totalInventory: typeInventory.length,
|
||
models: modelData,
|
||
regionSubtotals: INVENTORY_REGIONS.reduce(
|
||
(acc, reg) => {
|
||
acc[reg] = typeInventory.filter((v) => mapInventoryRegion(v.location) === reg).length;
|
||
return acc;
|
||
},
|
||
{} as Record<string, number>,
|
||
),
|
||
};
|
||
});
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
// GET /api/vehicles/dept-stats — department & manager breakdown with mileage/attendance
|
||
app.get('/dept-stats', async (c) => {
|
||
const vehicles = await getVehiclesForUser(c);
|
||
const withManager = vehicles.filter((v) => isOperatingVehicle(v));
|
||
|
||
// Query realtime day_mileage from tab_truck_remote_sync_realtime_info
|
||
const realtimeRows = await vehicleRepository.getRealtimeMileageRows();
|
||
const todayMileageMap = new Map<string, number>();
|
||
for (const row of realtimeRows as any[]) {
|
||
const plate = (row.plate_number || '').trim();
|
||
if (plate) todayMileageMap.set(plate, Number(row.day_mileage) || 0);
|
||
}
|
||
|
||
// 不在部门列表展示的用户（非业务员或管理账号）
|
||
const EXCLUDED_MANAGERS = new Set(['超级用户', '刘思宇', '潘舒', '黄卓华', '许铮杰']);
|
||
|
||
const deptMap = new Map<string, Map<string, Vehicle[]>>();
|
||
for (const v of withManager) {
|
||
const isPublicServiceVehicle = v.model === '公务车/挂靠车';
|
||
const dept = isPublicServiceVehicle ? '公务车' : (v.departmentName || '未分配部门');
|
||
const mgr = v.customerManager || '未分配';
|
||
if (EXCLUDED_MANAGERS.has(mgr)) continue;
|
||
if (!deptMap.has(dept)) deptMap.set(dept, new Map());
|
||
const mgrMap = deptMap.get(dept)!;
|
||
if (!mgrMap.has(mgr)) mgrMap.set(mgr, []);
|
||
mgrMap.get(mgr)!.push(v);
|
||
}
|
||
|
||
const result = Array.from(deptMap.entries()).map(([department, mgrMap]) => {
|
||
const allDeptVehicles = Array.from(mgrMap.values()).flat();
|
||
const deptMileage = getMileageStats(allDeptVehicles, todayMileageMap);
|
||
const managers = Array.from(mgrMap.entries())
|
||
.map(([manager, mvs]) => ({ manager, department, ...countByType(mvs) }))
|
||
.sort((a, b) => b.total - a.total);
|
||
return {
|
||
department,
|
||
totalAssets: allDeptVehicles.length,
|
||
operatingCount: allDeptVehicles.filter((v) => (todayMileageMap.get(v.plateNumber) || 0) > 0).length,
|
||
idleCount: allDeptVehicles.filter((v) => (todayMileageMap.get(v.plateNumber) || 0) === 0).length,
|
||
attendanceRate: deptMileage.attendanceRate,
|
||
avgMileage: deptMileage.avgMileage,
|
||
managers,
|
||
};
|
||
}).sort((a, b) => compareDepartmentNames(a.department, b.department));
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
// GET /api/vehicles/region-stats — macro-region with city drill-down
|
||
app.get('/region-stats', async (c) => {
|
||
const vehicles = await getVehiclesForUser(c);
|
||
const { customer, city: filterCity, region: filterRegion } = c.req.query();
|
||
let operating = vehicles.filter((v) => isOperatingVehicle(v) || isInventoryPending(v));
|
||
if (customer) operating = operating.filter((v) => v.customerName === customer);
|
||
if (filterCity) operating = operating.filter((v) => resolveCity(v.city, v.province) === filterCity);
|
||
if (filterRegion) operating = operating.filter((v) => mapMacroRegion(v.province, v.city) === filterRegion);
|
||
|
||
const regionCityMap = new Map<string, Map<string, Vehicle[]>>();
|
||
for (const v of operating) {
|
||
const region = mapMacroRegion(v.province, v.city);
|
||
const city = resolveCity(v.city, v.province);
|
||
if (!regionCityMap.has(region)) regionCityMap.set(region, new Map());
|
||
const cityMap = regionCityMap.get(region)!;
|
||
if (!cityMap.has(city)) cityMap.set(city, []);
|
||
cityMap.get(city)!.push(v);
|
||
}
|
||
|
||
const getTypeBreakdown = (vList: Vehicle[]) => {
|
||
const KNOWN = ['4.5T', '18T', '49T'] as const;
|
||
const make = (label: string, tv: Vehicle[]) => ({
|
||
type: label,
|
||
total: tv.length,
|
||
operating: tv.filter((v) => isOperatingVehicle(v)).length,
|
||
inventory: tv.filter((v) => isInventoryVehicle(v)).length,
|
||
abnormal: tv.filter((v) => isInventoryAbnormal(v)).length,
|
||
pending: tv.filter((v) => isInventoryPending(v)).length,
|
||
customers: Array.from(new Set(tv.map((v) => v.customerName).filter(Boolean))) as string[],
|
||
});
|
||
const known = KNOWN.map((type) => make(type, vList.filter((v) => v.type === type)));
|
||
const other = vList.filter((v) => !KNOWN.includes(v.type as typeof KNOWN[number]));
|
||
if (other.length > 0) known.push(make('其他', other));
|
||
return known.filter((t) => t.total > 0);
|
||
};
|
||
|
||
const regionOrder = ['华东', '华南', '华北', '华中', '西南', '西北', '其他'];
|
||
const result = regionOrder
|
||
.filter((r) => regionCityMap.has(r))
|
||
.map((region) => {
|
||
const cityMap = regionCityMap.get(region)!;
|
||
const allVehicles = Array.from(cityMap.values()).flat();
|
||
const customers = Array.from(new Set(allVehicles.map((v) => v.customerName).filter(Boolean))) as string[];
|
||
const allCities = Array.from(cityMap.entries())
|
||
.map(([city, cv]) => ({
|
||
city,
|
||
totalAssets: cv.length,
|
||
operatingCount: cv.filter((v) => isOperatingVehicle(v)).length,
|
||
pendingCount: cv.filter((v) => isInventoryPending(v)).length,
|
||
customers: Array.from(new Set(cv.map((v) => v.customerName).filter(Boolean))) as string[],
|
||
typeBreakdown: getTypeBreakdown(cv),
|
||
}))
|
||
.sort((a, b) => b.totalAssets - a.totalAssets);
|
||
|
||
// The UI uses collapsible city sections, so keep actual cities addressable for drill-down.
|
||
const cities = allCities;
|
||
|
||
return {
|
||
region,
|
||
totalAssets: allVehicles.length,
|
||
operatingCount: allVehicles.filter((v) => isOperatingVehicle(v)).length,
|
||
pendingCount: allVehicles.filter((v) => isInventoryPending(v)).length,
|
||
customers,
|
||
typeBreakdown: getTypeBreakdown(allVehicles),
|
||
cities,
|
||
};
|
||
});
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
// GET /api/vehicles/customer-stats — per-customer breakdown for operating vehicles
|
||
app.get('/customer-stats', async (c) => {
|
||
const vehicles = await getVehiclesForUser(c);
|
||
const operating = vehicles.filter((v) => isOperatingVehicle(v));
|
||
|
||
const custMap = new Map<string, Vehicle[]>();
|
||
for (const v of operating) {
|
||
const cust = v.customerName || '未分配客户';
|
||
if (!custMap.has(cust)) custMap.set(cust, []);
|
||
custMap.get(cust)!.push(v);
|
||
}
|
||
|
||
const result = Array.from(custMap.entries())
|
||
.map(([customer, cvs]) => {
|
||
const first = cvs[0];
|
||
return {
|
||
customer,
|
||
manager: first.customerManager || '',
|
||
brand: first.brandLabel || '',
|
||
department: first.departmentName || '',
|
||
region: mapMacroRegion(first.province, first.city),
|
||
city: first.city || '',
|
||
...countByType(cvs),
|
||
};
|
||
})
|
||
.sort((a, b) => b.total - a.total);
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
/** Analysis uses the same permission-filtered collection and exact entry scope as details. */
|
||
app.on(['GET', 'POST'], '/analysis', async (c) => {
|
||
const body = c.req.method === 'POST' ? await c.req.json().catch(() => null) : {};
|
||
if (!body || typeof body !== 'object' || Array.isArray(body)) return c.json({ error: '统计范围无效' }, 400);
|
||
const scope = body.scope || {};
|
||
if (!validAnalysisScope(scope) || (body.inventoryKeys !== undefined && (!Array.isArray(body.inventoryKeys) || !body.inventoryKeys.every((key: unknown) => typeof key === 'string')))) {
|
||
return c.json({ error: '统计范围无效' }, 400);
|
||
}
|
||
let vehicles = await filterVehicleListScope(await getVehiclesForUser(c), scope);
|
||
if (body.inventoryKeys) vehicles = await filterVehicleListScope(vehicles, { inventoryKeys: body.inventoryKeys });
|
||
const approvals = await loadMovementApprovalTimes(vehicles);
|
||
return c.json(buildAssetAnalysis(vehicles, approvals, Date.now()));
|
||
});
|
||
|
||
app.post('/analysis/details', async (c) => {
|
||
const body = await c.req.json().catch(() => null);
|
||
const filterValues = body?.filterValues === undefined ? {} : body.filterValues;
|
||
const metrics: AssetAnalysisMetric[] = ['assets', 'operating', 'inventory', 'abnormal', 'pending'];
|
||
if (!body || !metrics.includes(body.metric) || !validAnalysisFilters(body.filters || {}) || !validAnalysisScope(body.scope || {})
|
||
|| !validAnalysisFilterValues(filterValues)
|
||
|| (body.inventoryKeys !== undefined && (!Array.isArray(body.inventoryKeys) || !body.inventoryKeys.every((key: unknown) => typeof key === 'string')))) {
|
||
return c.json({ error: '下钻条件无效' }, 400);
|
||
}
|
||
const now = body.generatedAt === undefined ? Date.now() : typeof body.generatedAt === 'string' ? Date.parse(body.generatedAt) : NaN;
|
||
if (!Number.isFinite(now) || now > Date.now() + 60000) return c.json({ error: '统计时间无效，请刷新分析' }, 400);
|
||
let vehicles = await filterVehicleListScope(await getVehiclesForUser(c), body.scope || {});
|
||
if (body.inventoryKeys) vehicles = await filterVehicleListScope(vehicles, { inventoryKeys: body.inventoryKeys });
|
||
const approvals = await loadMovementApprovalTimes(vehicles);
|
||
const filtered = vehicles.filter(vehicle => {
|
||
const cell = analysisCellForVehicle(vehicle, approvals, now);
|
||
return matchesAnalysisMetric(cell, body.metric)
|
||
&& matchesAnalysisFilters(cell, body.filters || {})
|
||
&& matchesAnalysisFilterValues(cell, filterValues);
|
||
});
|
||
return c.json(filtered.map(vehicle => {
|
||
const result = vehicleListItem(vehicle);
|
||
const approvedAt = approvals.byMoveId.get(vehicle.abnormalMove?.id || '');
|
||
return {
|
||
...result,
|
||
abnormalMove: result.abnormalMove ? {
|
||
...result.abnormalMove,
|
||
approvalPassedAt: approvedAt || null,
|
||
elapsedDays: abnormalElapsedDays(approvedAt, now),
|
||
} : null,
|
||
};
|
||
}));
|
||
});
|
||
|
||
// POST uses a JSON scope to avoid URL length limits for inventory subtotal drilldown.
|
||
app.on(['GET', 'POST'], '/list', async (c) => {
|
||
let inventoryKeys: Set<string> | undefined;
|
||
if (c.req.method === 'POST') {
|
||
const body = await c.req.json().catch(() => null);
|
||
if (!body || !Array.isArray(body.inventoryKeys) || !body.inventoryKeys.every((key: unknown) => typeof key === 'string')) {
|
||
return c.json({ error: '库存明细范围无效' }, 400);
|
||
}
|
||
inventoryKeys = new Set(body.inventoryKeys);
|
||
}
|
||
const vehicles = await getVehiclesForUser(c);
|
||
const filtered = await filterVehicleListScope(vehicles, { ...c.req.query(), inventoryKeys: inventoryKeys ? [...inventoryKeys] : undefined });
|
||
return c.json(filtered.map(vehicleListItem));
|
||
});
|
||
|
||
async function filterVehicleListScope(vehicles: Vehicle[], scope: AssetAnalysisScope): Promise<Vehicle[]> {
|
||
const { brand, batch, model, location, status, category, vehicleType, manager, customer, isColdChain, isTrailer, department, attendance } = scope;
|
||
|
||
let filtered = scope.source === 'region'
|
||
? vehicles.filter(v => isOperatingVehicle(v) || isInventoryPending(v))
|
||
: vehicles;
|
||
|
||
const subject = (scope.subject || '').trim();
|
||
if (subject) filtered = filtered.filter(v => v.subjectOrg === subject);
|
||
const inventoryKeys = scope.inventoryKeys ? new Set(scope.inventoryKeys) : undefined;
|
||
if (inventoryKeys) {
|
||
filtered = filtered.filter(v => isInventoryVehicle(v) && inventoryKeys.has(inventoryKey(inventoryDimensions(v))));
|
||
}
|
||
|
||
// attendance filter: active = day_mileage > 0, idle = day_mileage = 0 (only for Operating vehicles)
|
||
if (attendance === 'active' || attendance === 'idle') {
|
||
const realtimeRows = await vehicleRepository.getAttendanceMileageRows();
|
||
const todayMap = new Map<string, number>();
|
||
for (const row of realtimeRows as any[]) todayMap.set((row.plate_number || '').trim(), Number(row.day_mileage) || 0);
|
||
filtered = filtered.filter((v) => isOperatingVehicle(v));
|
||
if (attendance === 'active') {
|
||
filtered = filtered.filter((v) => (todayMap.get(v.plateNumber) || 0) > 0);
|
||
} else {
|
||
filtered = filtered.filter((v) => (todayMap.get(v.plateNumber) || 0) === 0);
|
||
}
|
||
}
|
||
if (vehicleType) {
|
||
if (vehicleType === '区域其他' && scope.source === 'region') {
|
||
filtered = filtered.filter(v => !['4.5T', '18T', '49T'].includes(v.type));
|
||
} else if (VEHICLE_TYPE_FILTERS[vehicleType]) {
|
||
filtered = filtered.filter(VEHICLE_TYPE_FILTERS[vehicleType]);
|
||
} else if (vehicleType === '4.5T') {
|
||
filtered = filtered.filter((v) => v.type === '4.5T');
|
||
} else {
|
||
filtered = filtered.filter((v) => v.type === vehicleType);
|
||
}
|
||
}
|
||
if (brand) {
|
||
filtered = filtered.filter((v) => (v.brandLabel || '未知') === brand);
|
||
}
|
||
if (batch && batch !== 'All') {
|
||
filtered = filtered.filter((v) => (v.contractNo || '未知') === batch);
|
||
}
|
||
if (model && model !== 'All') {
|
||
filtered = filtered.filter((v) => v.model === model);
|
||
}
|
||
if (location && location !== 'All') {
|
||
filtered = filterByLocation(filtered, location, scope.source);
|
||
}
|
||
if (status && status !== 'All') {
|
||
filtered = filtered.filter((v) => v.status === status);
|
||
}
|
||
if (category) {
|
||
if (category === 'Inventory') {
|
||
filtered = filtered.filter((v) => isInventoryVehicle(v));
|
||
} else if (category === 'Abnormal') {
|
||
filtered = filtered.filter((v) => isInventoryAbnormal(v));
|
||
} else if (category === 'Operating') {
|
||
filtered = filtered.filter((v) => isOperatingVehicle(v));
|
||
} else if (category === 'Pending') {
|
||
filtered = filtered.filter((v) => isInventoryPending(v));
|
||
}
|
||
}
|
||
if (manager) {
|
||
filtered = filtered.filter((v) => manager === '未分配' ? !v.customerManager : v.customerManager === manager);
|
||
}
|
||
if (customer) {
|
||
filtered = filtered.filter((v) => customer === '未分配客户' ? !v.customerName : v.customerName === customer);
|
||
}
|
||
if (department) {
|
||
filtered = filtered.filter((v) => {
|
||
if (department === '公务车') return v.model === '公务车/挂靠车';
|
||
if (department === '未分配部门') return v.model !== '公务车/挂靠车' && !v.departmentName;
|
||
return v.departmentName === department;
|
||
});
|
||
}
|
||
if (isColdChain !== undefined) {
|
||
const wantCold = isColdChain === 'true';
|
||
filtered = filtered.filter((v) => wantCold ? v.model.includes('冷链') : !v.model.includes('冷链'));
|
||
}
|
||
if (isTrailer !== undefined) {
|
||
const wantTrailer = isTrailer === 'true';
|
||
filtered = filtered.filter((v) => wantTrailer ? (v.type === '挂车' || v.model.includes('挂车')) : !(v.type === '挂车' || v.model.includes('挂车')));
|
||
}
|
||
|
||
return filtered;
|
||
}
|
||
|
||
function vehicleListItem(v: Vehicle) {
|
||
return {
|
||
id: v.id,
|
||
plateNumber: v.plateNumber,
|
||
vin: v.vin,
|
||
type: v.type,
|
||
model: v.model,
|
||
location: v.location,
|
||
color: v.color,
|
||
operationStatus: v.operationStatus,
|
||
inventoryKey: inventoryKey(inventoryDimensions(v)),
|
||
province: v.province,
|
||
city: v.city,
|
||
status: v.status,
|
||
ownership: v.ownership,
|
||
rentCompany: v.rentCompany,
|
||
contractNo: v.contractNo,
|
||
customerName: v.customerName,
|
||
abnormalMove: v.abnormalMove ?? null,
|
||
pendingDelivery: v.pendingDelivery ?? null,
|
||
subjectOrg: v.subjectOrg,
|
||
departmentName: v.departmentName,
|
||
customerManager: v.customerManager,
|
||
opsManagers: v.opsManagers || null,
|
||
brandLabel: v.brandLabel,
|
||
orgName: v.orgName,
|
||
};
|
||
}
|
||
|
||
|
||
// Inventory keeps its existing aggregate visibility; vehicle details retain user permissions.
|
||
const INVENTORY_TYPE_NAMES: Record<string, string> = { t4_5: '4.5T普货', t4_5c: '4.5T冷链', t18: '18T', t49: '49T', trailer: '挂车', other: '其他' };
|
||
function inventoryDimensions(v: Vehicle) {
|
||
return { region: mapMacroRegion(v.province, v.city), city: resolveCity(v.city, v.province), brand: v.brandLabel || '未知', type: INVENTORY_TYPE_NAMES[classifyVehicleType({ ...v, model: v.model || "" })], model: v.model || "未标注型号" };
|
||
}
|
||
app.get('/inventory-stats', async (c) => {
|
||
const vehicles = applySubjectFilter(c, await vehicleRepository.getVehicles());
|
||
const groups = new Map<string, ReturnType<typeof inventoryDimensions> & InventoryCounts & { batch: string; variants: Record<string, InventoryCounts> }>();
|
||
for (const v of vehicles.filter(isInventoryVehicle)) {
|
||
const dimensions = inventoryDimensions(v);
|
||
const key = inventoryKey(dimensions);
|
||
const row = groups.get(key) || { ...dimensions, batch: v.model, ...emptyInventoryCounts(), variants: {} };
|
||
const color = inventoryColor(v.color);
|
||
const variant = row.variants[color] || emptyInventoryCounts();
|
||
for (const count of [row, variant]) {
|
||
count.quantity += 1;
|
||
count[inventoryOperation(v.operationStatus)] += 1;
|
||
if (isInventoryPending(v)) count.pending += 1;
|
||
if (isInventoryAbnormal(v)) {
|
||
count.abnormal += 1;
|
||
const type = v.abnormalMove?.type || '未提供';
|
||
count.abnormalTypes[type] = (count.abnormalTypes[type] || 0) + 1;
|
||
}
|
||
}
|
||
row.variants[color] = variant;
|
||
groups.set(key, row);
|
||
}
|
||
return c.json([...groups.values()].sort((a, b) => b.quantity - a.quantity));
|
||
});
|
||
|
||
// GET /api/vehicles/weekly-detail?type=delivered|returned|replaced|pending
|
||
// Optional filters: model, batch, location, source — 按缓存车辆集合的 truck_id 交集过滤
|
||
app.get('/weekly-detail', async (c) => {
|
||
const type = c.req.query('type');
|
||
const { model, batch, location } = c.req.query();
|
||
const source = c.req.query('source');
|
||
const validTypes: WeeklyDetailType[] = ['delivered', 'returned', 'replaced', 'pending', 'new'];
|
||
if (!validTypes.includes(type as WeeklyDetailType)) {
|
||
return c.json([]);
|
||
}
|
||
let result = await vehicleRepository.getWeeklyDetailRows(type as WeeklyDetailType);
|
||
|
||
// 按型号/批次/区域过滤：借助缓存车辆集，取 truck_id 交集
|
||
const hasModelFilter = model && model !== 'All';
|
||
const hasBatchFilter = batch && batch !== 'All';
|
||
const hasLocationFilter = location && location !== 'All';
|
||
{
|
||
// Public current inventory does not grant access to historical delivery/return events.
|
||
const vehicles = await getVehiclesForUser(c, type === 'pending');
|
||
let pool2 = vehicles;
|
||
if (hasModelFilter) pool2 = pool2.filter((v) => v.model === model);
|
||
if (hasBatchFilter) pool2 = pool2.filter((v) => (v.contractNo || '未知') === batch);
|
||
if (hasLocationFilter) pool2 = filterByLocation(pool2, location, source);
|
||
const truckSet = new Set(pool2.map((v) => String(v.id)));
|
||
result = result.filter((r: any) => truckSet.has(String(r.truck_id)));
|
||
}
|
||
|
||
const masked = result.map(r => ({ ...r, customer_name: maskCustomerName(r.customer_name) }));
|
||
return c.json(masked);
|
||
});
|
||
|
||
// GET /api/vehicles/flow-stats?start=YYYY-MM-DD&end=YYYY-MM-DD
|
||
// 资产流转日报：按运维签章时间统计业务车次；交车包含关联替换单的记录，替换作为其中的子项，同车多笔业务分别累计。
|
||
app.get('/flow-stats', async (c) => {
|
||
const { start, end } = normalizeDateRange(c.req.query('start'), c.req.query('end'));
|
||
const allowedVehicles = await getVehiclesForUser(c, false);
|
||
const allowedTruckIds = new Set(allowedVehicles.map((v) => String(v.id)));
|
||
|
||
const rows = await vehicleRepository.getFlowDetailRows(start, end);
|
||
|
||
const details = (rows as FlowDetailRow[])
|
||
.filter((row) => allowedTruckIds.has(String(row.truck_id)))
|
||
.map((row) => ({
|
||
id: row.id,
|
||
type: row.type,
|
||
typeLabel: row.type_label,
|
||
date: row.stat_date,
|
||
truckId: row.truck_id,
|
||
plateNumber: row.plate_number,
|
||
eventTime: row.event_time,
|
||
submitTime: row.submit_time,
|
||
department: row.department || '',
|
||
manager: row.manager || '',
|
||
customerName: maskCustomerName(row.customer_name),
|
||
contractNo: row.contract_no || null,
|
||
projectName: row.project_name || null,
|
||
}));
|
||
|
||
const dailyMap = new Map<string, { date: string; delivered: number; returned: number; replaced: number; total: number }>();
|
||
for (const date of listDateRange(start, end)) dailyMap.set(date, { date, delivered: 0, returned: 0, replaced: 0, total: 0 });
|
||
for (const item of details) {
|
||
const stat = dailyMap.get(item.date);
|
||
if (!stat) continue;
|
||
stat[item.type] += 1;
|
||
if (item.type === 'replaced') stat.delivered += 1;
|
||
stat.total += 1;
|
||
}
|
||
|
||
const daily = Array.from(dailyMap.values());
|
||
const totals = daily.reduce(
|
||
(acc, item) => ({
|
||
delivered: acc.delivered + item.delivered,
|
||
returned: acc.returned + item.returned,
|
||
replaced: acc.replaced + item.replaced,
|
||
total: acc.total + item.total,
|
||
}),
|
||
{ delivered: 0, returned: 0, replaced: 0, total: 0 },
|
||
);
|
||
|
||
return c.json({ start, end, daily, totals, details });
|
||
});
|
||
|
||
// GET /api/vehicles/subjects — 归属公司列表（含台数预览），用于顶部筛选下拉
|
||
app.get('/subjects', async (c) => {
|
||
const all = await vehicleRepository.getVehicles();
|
||
const user = ((c as any).get?.('user') || (c as any).var?.user) as AuthUser | undefined;
|
||
const visible = user ? filterAssetVehiclesByPermission(all, user) : all;
|
||
|
||
const map = new Map<string, { total: number; inventory: number; operating: number }>();
|
||
for (const v of visible) {
|
||
const name = (v.subjectOrg || '').trim();
|
||
if (!name) continue;
|
||
if (!map.has(name)) map.set(name, { total: 0, inventory: 0, operating: 0 });
|
||
const s = map.get(name)!;
|
||
s.total += 1;
|
||
if (isInventoryVehicle(v)) s.inventory += 1;
|
||
if (isOperatingVehicle(v)) s.operating += 1;
|
||
}
|
||
|
||
const result = Array.from(map.entries())
|
||
.map(([name, stats]) => ({ name, ...stats }))
|
||
.sort((a, b) => b.total - a.total);
|
||
|
||
return c.json(result);
|
||
});
|
||
|
||
// GET /api/vehicles/refresh — force cache refresh
|
||
app.get('/refresh', async (c) => {
|
||
vehicleRepository.invalidateRefreshCaches();
|
||
const vehicles = await getVehiclesForUser(c);
|
||
return c.json({ message: 'Cache refreshed', count: vehicles.length });
|
||
});
|
||
|
||
// GET /api/vehicles/debug — debug weekly date range and raw counts
|
||
app.get('/debug', async (c) => {
|
||
const { dateRange, deliveredAll, deliveredRecent, latestTake, returnedRecent, latestReturn } = await vehicleRepository.getWeeklyDebugData();
|
||
|
||
return c.json({
|
||
weekRange: dateRange,
|
||
delivered: { total: deliveredAll[0]?.cnt, thisWeek: deliveredRecent[0]?.cnt, latestDate: latestTake[0]?.latest },
|
||
returned: { thisWeek: returnedRecent[0]?.cnt, latestDate: latestReturn[0]?.latest },
|
||
});
|
||
});
|
||
|
||
// GET /api/vehicles/region-chart — aggregated chart data with top N + "其他"
|
||
app.get('/region-chart', async (c) => {
|
||
const vehicles = await getVehiclesForUser(c);
|
||
const operating = vehicles.filter((v) => isOperatingVehicle(v));
|
||
const groupBy = c.req.query('groupBy') || 'region'; // 'region' | 'province'
|
||
const source = c.req.query('source') || 'realtime'; // 'realtime' | 'vehicle'
|
||
const top = Number(c.req.query('top')) || 8;
|
||
|
||
let counts: Map<string, number>;
|
||
if (groupBy === 'province') {
|
||
counts = new Map<string, number>();
|
||
if (source === 'vehicle') {
|
||
// Use vehicle table's own province field
|
||
for (const v of operating) {
|
||
const prov = (v.province || '').replace(/省|市$/, '').trim() || '未知';
|
||
counts.set(prov, (counts.get(prov) || 0) + 1);
|
||
}
|
||
} else {
|
||
// Use realtime table province
|
||
const rows = await vehicleRepository.getRealtimeProvinceRows();
|
||
const plateProvince = new Map<string, string>();
|
||
for (const row of rows as any[]) {
|
||
const plate = (row.plate_number || '').trim();
|
||
const prov = (row.province || '').replace(/省|市$/, '').trim();
|
||
if (plate && prov) plateProvince.set(plate, prov);
|
||
}
|
||
for (const v of operating) {
|
||
const prov = plateProvince.get(v.plateNumber) || '未知';
|
||
counts.set(prov, (counts.get(prov) || 0) + 1);
|
||
}
|
||
}
|
||
} else {
|
||
counts = new Map<string, number>();
|
||
for (const v of operating) {
|
||
const key = mapMacroRegion(v.province, v.city);
|
||
counts.set(key, (counts.get(key) || 0) + 1);
|
||
}
|
||
}
|
||
|
||
// 分离"其他"和"未知"，对剩余排序取 Top N，其余全部合入"其他"
|
||
const otherCount = (counts.get('其他') || 0) + (counts.get('未知') || 0);
|
||
counts.delete('其他');
|
||
counts.delete('未知');
|
||
|
||
const sorted = Array.from(counts.entries())
|
||
.map(([name, value]) => ({ name, value }))
|
||
.sort((a, b) => b.value - a.value);
|
||
|
||
const result = sorted.slice(0, top);
|
||
const restTotal = sorted.slice(top).reduce((s, item) => s + item.value, 0) + otherCount;
|
||
if (restTotal > 0) result.push({ name: '其他', value: restTotal });
|
||
return c.json(result);
|
||
});
|
||
|
||
export default app;
|