liufumingren afda527deb fix: 录像回写统一UTC时间基准并按仓库校验,失败/缺失行均落库
- 原视频表写入时间由 NOW() 改为 UTC_TIMESTAMP()(WMS Sequelize 默认 +00:00,服务器为 CST+8)

- 回信先取任务行做仓库归属校验,跨仓或不存在的任务直接拒绝写入

- receiveTask 回 ok=false 时落 status=failed,避免录像行卡在 created

- 新增 _findVideoRow:camera_id 未命中且任务仅单行时退化为按任务ID定位(多路不猜)

- 新增 _insertVideoResult:录像行缺失时兜底插入结果行,保证 WMS 能收敛状态
2026-09-11 02:22:26 +08:00

651 lines
30 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

const BaseService = require('./base');
/**
* 海康录像任务服务
* 客户端通过 WebSocket 调用:
* hikvision.fetchTasks - 拉取待录像的打包任务
* hikvision.receiveTask - 确认接收任务,更新状态为 recording
* hikvision.taskComplete - 任务完成回调,写入结果
*/
class HikvisionService extends BaseService {
/**
* 将 MySQL DATETIME(存储为 UTC)转为 ISO 8601 北京时间 (+08:00)
* @param {string} datetime - DB 时间
* @param {number} offsetMs - 额外偏移(ms),负数=提前
*/
_toISO(datetime, offsetMs = 0) {
if (!datetime) return null;
const str = String(datetime).trim();
const utc = new Date(str + 'Z');
const cst = new Date(utc.getTime() + 8 * 3600000 + offsetMs);
return cst.toISOString().replace('Z', '+08:00');
}
/**
* 获取任务类型配置(打包/拆包共用)
* @param {string} taskType - 'pack' | 'unpack'
*/
_getTaskCfg(taskType) {
if (taskType === 'unpack') {
return {
taskType: 'unpack',
taskTable: 'wms_return_unpack',
videoTable: 'wms_return_unpack_video',
fkColumn: 'unpack_id',
cameraIdsField: 'camera_ids',
codePrefix: 'unpack_',
workbenchMatch: false,
endOffsetMs: 5000, // 拆包录像结束时间往后延 5 秒
buildFields: (task, cameraId) => ({
task_type: 'unpack',
unpack_id: task.id,
device_id: cameraId,
order_id: task.order_id,
warehouse_id: task.warehouse_id,
unpack_no: task.unpack_no,
waybill_code: task.waybill_code,
}),
};
}
return {
taskType: 'pack',
taskTable: 'wms_pack_task',
videoTable: 'wms_pack_task_video',
fkColumn: 'pack_task_id',
cameraIdsField: 'device_ids',
codePrefix: '',
workbenchMatch: true,
endOffsetMs: 0, // 打包结束时间不延后
buildFields: (task, cameraId) => ({
task_type: 'pack',
pack_task_id: task.id,
device_id: cameraId,
order_id: task.order_id,
warehouse_id: task.warehouse_id,
workbench_id: task.workbench_id,
wave_no: task.wave_no,
waybill_code: task.waybill_code,
}),
};
}
/**
* 校验回信电脑与任务是否同仓库(防跨仓误写)
* print_computer_info 缺失(客户端未走 auth.getInfo)时只告警不阻断
* @param {Object} task 任务行(需含 warehouse_id)
* @param {string} method 调用方方法名(日志用)
* @returns {{ok: boolean, message?: string}}
*/
_checkTaskWarehouse(task, method) {
const { print_computer_info: info } = this.ctx;
const taskWarehouse = task && task.warehouse_id;
if (!info || !info.warehouse) {
console.warn(`[Hikvision] ${method} 缺少电脑绑定信息,跳过仓库校验: task=${task && task.id}, taskWarehouse=${taskWarehouse}`);
return { ok: true };
}
if (String(info.warehouse) !== String(taskWarehouse)) {
console.warn(`[Hikvision] ${method} 仓库不匹配,拒绝写入: 电脑仓库=${info.warehouse}, 任务仓库=${taskWarehouse}, task=${task.id}`);
return { ok: false, message: '任务与当前电脑仓库不匹配' };
}
return { ok: true };
}
/**
* 定位录像行:先按 任务ID + 摄像头ID 精准定位(避免多摄像头/forceRecord 并发错位);
* 精准定位不到时,仅当该任务只有一行录像行才退化为按任务ID定位(多路场景不猜)
* @returns {Promise<Object|null>} 录像行,定位不到返回 null
*/
async _findVideoRow(videoTable, fkColumn, taskIdNum, cameraIdNum) {
const { app } = this;
const mysql = app.mysql.get('wms');
const cond = { [fkColumn]: taskIdNum, deleted_at: null };
if (!isNaN(cameraIdNum)) cond.camera_id = cameraIdNum;
const [row] = await mysql.select(videoTable, {
where: cond,
orders: [ [ 'id', 'desc' ] ],
limit: 1,
});
if (row) return row;
const rows = await mysql.select(videoTable, {
where: { [fkColumn]: taskIdNum, deleted_at: null },
orders: [ [ 'id', 'desc' ] ],
limit: 2,
});
if (!rows || rows.length === 0) return null;
if (rows.length > 1) {
console.warn(`[Hikvision] 录像行定位失败且该任务存在多路录像行,跳过更新: ${fkColumn}=${taskIdNum}, camera=${cameraIdNum}`);
return null;
}
console.warn(`[Hikvision] 录像行按 camera_id 未命中,退化为按任务ID更新: ${fkColumn}=${taskIdNum}, camera=${cameraIdNum}, videoId=${rows[0].id}`);
return rows[0];
}
/**
* 兜底落结果行:录像行缺失时直接插入一行结果,
* 保证 WMS 能按原视频表(status / video_url)收敛补录请求状态
*/
async _insertVideoResult(videoTable, fkColumn, taskIdNum, cameraIdNum, { status, videoUrl = '', remark = null }) {
const { app } = this;
const cols = [ fkColumn ];
const params = [ taskIdNum ];
if (!isNaN(cameraIdNum)) {
cols.push('camera_id');
params.push(cameraIdNum);
}
cols.push('video_url', 'status', 'remark');
params.push(videoUrl, status, remark);
await app.mysql.get('wms').query(
`INSERT INTO ${videoTable} (${cols.join(', ')}, created_at, updated_at)
VALUES (${cols.map(() => '?').join(', ')}, UTC_TIMESTAMP(), UTC_TIMESTAMP())`,
params
);
}
/**
* 组装录像任务落参,并用原子 INSERT 创建录像占位记录(防止并发重复)
* 注:不使用显式事务(egg-mysql 5 + mysql2 3.23 的事务 conn.query 存在挂起 bug),
* 改用 INSERT ... SELECT ... WHERE NOT EXISTS 原子防重。
* @param {Object} task 任务行(wms_pack_task 或 wms_return_unpack)
* @param {Object} cfg 任务类型配置
* - videoTable: 录像表名
* - fkColumn: 外键列名(pack_task_id / unpack_id)
* - cameraIdsField: 摄像头ID字段名(device_ids / camera_ids)
* - codePrefix: uniqueCode 前缀(打包为空,拆包为 unpack_)
* - workbenchMatch: 是否启用工作台名匹配摄像头
* - buildFields: (task, cameraId) => 落参基础字段
* - cameras / servers: 仓库摄像头与服务器列表
* @returns {Promise<Object[]>} 落参数组
*/
async _collectVideoItems(task, cfg) {
const { app } = this;
let cameraIds = [];
try {
cameraIds = typeof task[cfg.cameraIdsField] === 'string'
? JSON.parse(task[cfg.cameraIdsField])
: (task[cfg.cameraIdsField] || []);
} catch (e) {
cameraIds = [];
}
const items = [];
for (const cameraId of cameraIds) {
// 按设备ID匹配摄像头
let matchedCamera = cfg.cameras.find(c => c.id === cameraId);
if (!matchedCamera && cfg.workbenchMatch && task.workbench_id) {
matchedCamera = cfg.cameras.find(
c => c.custom_name && c.custom_name.includes(`${task.workbench_id}号`)
);
}
if (!matchedCamera) matchedCamera = cfg.cameras[0];
if (!matchedCamera) continue;
const matchedServer = cfg.servers.find(s => s.id === matchedCamera.server_id) || cfg.servers[0];
if (!matchedServer) continue;
// 原子插入防重:仅当该任务+摄像头没有未删除录像行时插入
// 时间统一 UTC_TIMESTAMP():WMS 侧 Sequelize 未配 timezone(默认 +00:00),库内时间为 UTC
await app.mysql.get('wms').query(
`INSERT INTO ${cfg.videoTable} (${cfg.fkColumn}, camera_id, video_url, status, created_at, updated_at)
SELECT ?, ?, '', 'created', UTC_TIMESTAMP(), UTC_TIMESTAMP()
FROM DUAL
WHERE NOT EXISTS (
SELECT 1 FROM ${cfg.videoTable}
WHERE ${cfg.fkColumn} = ? AND camera_id = ? AND deleted_at IS NULL
)`,
[task.id, matchedCamera.id, task.id, matchedCamera.id]
);
items.push({
...cfg.buildFields(task, cameraId),
uniqueCode: `${cfg.codePrefix}${task.id}_${cameraId}`,
task_status: task.task_status,
start_time: this._toISO(task.start_time, -5000),
end_time: this._toISO(task.end_time, cfg.endOffsetMs || 0),
operator: task.operator_text,
camera: {
id: matchedCamera.id,
channel_id: matchedCamera.channel_id,
channel_name: matchedCamera.channel_name,
ip: matchedCamera.ip,
port: matchedCamera.port,
model: matchedCamera.model,
custom_name: matchedCamera.custom_name,
},
server: {
id: matchedServer.id,
brand: matchedServer.brand,
internal_ip: matchedServer.internal_ip,
internal_port: matchedServer.internal_port || 80,
username: matchedServer.username,
password: matchedServer.password,
},
});
}
return items;
}
/**
* 拉取待录像任务
* 查询 wms_pack_task(打包)与 wms_return_unpack(拆包)中无录像记录的任务
* 返回任务信息 + 摄像头信息 + 服务器信息
*/
async fetchTasks(data) {
const { app } = this;
const { print_computer_info } = this.ctx;
if (!print_computer_info) {
return this.errorResponse('hikvision.fetchTasks', '未绑定打印电脑信息');
}
const warehouseId = print_computer_info.warehouse;
try {
// 1. 查询该仓库待录像的打包任务(pack_mode=1, 状态不是已完成, 未删除)
const tasks = await app.mysql.get('wms').query(
`SELECT t.id, t.order_id, t.warehouse_id, t.workbench_id,
t.wave_no, t.waybill_code, t.device_ids, t.status AS task_status,
t.start_time, t.end_time, t.operator_text
FROM wms_pack_task t
WHERE t.warehouse_id = ?
AND t.deleted_at IS NULL
AND t.end_time IS NOT NULL
AND t.device_ids IS NOT NULL
AND t.device_ids != '[]'
AND t.id NOT IN (
SELECT v.pack_task_id FROM wms_pack_task_video v WHERE v.deleted_at IS NULL
)
ORDER BY t.id DESC
LIMIT 20`,
[warehouseId]
);
const tasks2 = await app.mysql.get('wms').query(
`SELECT t.id, t.order_id, t.warehouse_id, t.unpack_no,
t.waybill_code, t.camera_ids, t.status AS task_status,
t.start_time, t.end_time, t.unpacker_name AS operator_text
FROM wms_return_unpack t
WHERE t.warehouse_id = ?
AND t.end_time IS NOT NULL
AND t.camera_ids IS NOT NULL
AND t.camera_ids != '[]'
AND t.id NOT IN (
SELECT v.unpack_id FROM wms_return_unpack_video v WHERE v.deleted_at IS NULL
)
ORDER BY t.id DESC
LIMIT 20`,
[warehouseId]
);
if ((!tasks || tasks.length === 0) && (!tasks2 || tasks2.length === 0)) {
return this.successResponse('hikvision.fetchTasks', [], '暂无待录像任务');
}
// 2. 获取该仓库的摄像头服务器信息
const servers = await app.mysql.get('wms').select('wms_camera_server', {
where: { warehouse_id: warehouseId, deleted_at: null, status: 1 },
});
// 3. 获取该仓库的摄像头列表
const cameras = await app.mysql.get('wms').select('wms_camera', {
where: { warehouse_id: warehouseId, deleted_at: null, status: 1 },
});
// 4. 组装返回数据:每个任务的每个摄像头返回一条(先打包后拆包)
const packCfg = this._getTaskCfg('pack');
const unpackCfg = this._getTaskCfg('unpack');
const result = [];
for (const task of tasks || []) {
result.push(...await this._collectVideoItems(task, { ...packCfg, cameras, servers }));
}
for (const task of tasks2 || []) {
result.push(...await this._collectVideoItems(task, { ...unpackCfg, cameras, servers }));
}
console.log(`[Hikvision] 仓库 ${warehouseId} 返回 ${result.length} 个待录像任务`);
return this.successResponse('hikvision.fetchTasks', result, '查询成功');
} catch (error) {
console.error('[Hikvision] fetchTasks 错误:', error);
return this.errorResponse('hikvision.fetchTasks', error.message);
}
}
/**
* 客户端确认接收任务
* 创建 wms_pack_task_video 记录,状态改为 recording
*/
async receiveTask(data) {
const { app } = this;
const { taskId, uniqueCode, ok, message, task_type } = data || {};
if (!uniqueCode) {
return this.errorResponse('hikvision.receiveTask', '缺少 uniqueCode');
}
try {
// 判断任务类型:优先用回信 task_type,缺失时回退 uniqueCode 前缀
// (拆包: unpack_{task_id}_{camera_id};打包: {task_id}_{device_id})
let isUnpack;
if (task_type === 'pack' || task_type === 'unpack') {
isUnpack = task_type === 'unpack';
} else {
isUnpack = uniqueCode.startsWith('unpack_');
}
const parts = uniqueCode.split('_');
const taskIdNum = parseInt(isUnpack ? parts[1] : parts[0]);
const cameraIdNum = parseInt(parts[parts.length - 1]);
if (!taskIdNum) {
return this.errorResponse('hikvision.receiveTask', `无法解析任务ID: ${uniqueCode}`);
}
const videoTable = isUnpack ? 'wms_return_unpack_video' : 'wms_pack_task_video';
const fkColumn = isUnpack ? 'unpack_id' : 'pack_task_id';
const cfg = this._getTaskCfg(isUnpack ? 'unpack' : 'pack');
// 取任务行:仓库归属校验 + 录像行缺失时兜底落库用
const task = await app.mysql.get('wms').get(cfg.taskTable, { id: taskIdNum });
if (!task) {
return this.errorResponse('hikvision.receiveTask', `任务不存在: ${cfg.taskTable}#${taskIdNum}`);
}
const whCheck = this._checkTaskWarehouse(task, 'hikvision.receiveTask');
if (!whCheck.ok) {
return this.errorResponse('hikvision.receiveTask', whCheck.message);
}
if (ok) {
// 任务接收成功 → 定位该摄像头录像行,状态改为 recording
const existingVideo = await this._findVideoRow(videoTable, fkColumn, taskIdNum, cameraIdNum);
if (!existingVideo) {
if (!isNaN(cameraIdNum)) {
await app.mysql.get('wms').query(
`INSERT INTO ${videoTable} (${fkColumn}, camera_id, video_url, status, remark, created_at, updated_at)
VALUES (?, ?, '', 'recording', ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())`,
[taskIdNum, cameraIdNum, message || '任务已接收']
);
} else {
await app.mysql.get('wms').query(
`INSERT INTO ${videoTable} (${fkColumn}, video_url, status, remark, created_at, updated_at)
VALUES (?, '', 'recording', ?, UTC_TIMESTAMP(), UTC_TIMESTAMP())`,
[taskIdNum, message || '任务已接收']
);
}
} else if (existingVideo.status === 'created') {
await app.mysql.get('wms').query(
`UPDATE ${videoTable} SET status = 'recording', remark = ?, updated_at = UTC_TIMESTAMP() WHERE id = ?`,
[message || '任务已接收', existingVideo.id]
);
}
console.log(`[Hikvision] 录像开始: ${fkColumn}=${taskIdNum}, taskId=${taskId}`);
return this.successResponse('hikvision.receiveTask', { [fkColumn]: taskIdNum, status: 'recording' }, '录像已开始');
} else {
// 任务接收失败(录制电脑拒绝/摄像头连不上)→ 落 failed,
// 否则该行停在 created,WMS 既非“录制中”也非“全部失败”,只能等 1 小时超时转人工
const failedRow = await this._findVideoRow(videoTable, fkColumn, taskIdNum, cameraIdNum);
if (failedRow) {
await app.mysql.get('wms').query(
`UPDATE ${videoTable} SET status = 'failed', remark = ?, updated_at = UTC_TIMESTAMP() WHERE id = ?`,
[message || '任务接收失败', failedRow.id]
);
} else {
await this._insertVideoResult(videoTable, fkColumn, taskIdNum, cameraIdNum, {
status: 'failed',
remark: message || '任务接收失败',
});
}
console.log(`[Hikvision] 任务接收失败(已落 failed): ${fkColumn}=${taskIdNum}, message=${message}`);
return this.errorResponse('hikvision.receiveTask', message || '任务接收失败');
}
} catch (error) {
console.error('[Hikvision] receiveTask 错误:', error);
return this.errorResponse('hikvision.receiveTask', error.message);
}
}
/**
* 客户端回调:录像任务完成
* 成功 → 写入 video_url,状态 completed
* 失败 → 写入 remark,状态 failed
* 注:按对接口径,通知方只写原视频表;wms_video_record_request 由 WMS 全权维护,
* WMS 定时任务(settleStatuses)会据此收敛补录请求状态并回信
*/
async taskComplete(data) {
const { app } = this;
const { taskId, uniqueCode, status, success, output, size, duration, speed, fileUrl, error: errorMsg, task_type } = data || {};
if (!uniqueCode) {
return this.errorResponse('hikvision.taskComplete', '缺少 uniqueCode');
}
try {
// 判断任务类型:优先用回信 task_type,缺失时回退 uniqueCode 前缀
// (拆包: unpack_{task_id}_{camera_id};打包: {task_id}_{device_id})
let isUnpack;
if (task_type === 'pack' || task_type === 'unpack') {
isUnpack = task_type === 'unpack';
} else {
isUnpack = uniqueCode.startsWith('unpack_');
}
const parts = uniqueCode.split('_');
const taskIdNum = parseInt(isUnpack ? parts[1] : parts[0]);
const cameraIdNum = parseInt(parts[parts.length - 1]);
if (!taskIdNum) {
return this.errorResponse('hikvision.taskComplete', `无法解析任务ID: ${uniqueCode}`);
}
const videoTable = isUnpack ? 'wms_return_unpack_video' : 'wms_pack_task_video';
const fkColumn = isUnpack ? 'unpack_id' : 'pack_task_id';
const cfg = this._getTaskCfg(isUnpack ? 'unpack' : 'pack');
// 取任务行:仓库归属校验(防跨仓误写)+ 录像行缺失时兜底落库用
const task = await app.mysql.get('wms').get(cfg.taskTable, { id: taskIdNum });
if (!task) {
return this.errorResponse('hikvision.taskComplete', `任务不存在: ${cfg.taskTable}#${taskIdNum}`);
}
const whCheck = this._checkTaskWarehouse(task, 'hikvision.taskComplete');
if (!whCheck.ok) {
return this.errorResponse('hikvision.taskComplete', whCheck.message);
}
if (success && status === 'completed') {
// 定位该摄像头录像行(带单路退化兜底)
const latestVideo = await this._findVideoRow(videoTable, fkColumn, taskIdNum, cameraIdNum);
const remarkText = `大小:${(size / 1024 / 1024).toFixed(2)}MB, 时长:${duration}s, 倍速:${speed}x`;
if (latestVideo) {
await app.mysql.get('wms').query(
`UPDATE ${videoTable} SET video_url = ?, status = 'completed', remark = ?, updated_at = UTC_TIMESTAMP() WHERE id = ?`,
[fileUrl || output || '', remarkText, latestVideo.id]
);
} else {
// 录像行缺失(如未落库/被删)→ 直接落一行结果,保证 WMS 能收敛状态
await this._insertVideoResult(videoTable, fkColumn, taskIdNum, cameraIdNum, {
status: 'completed',
videoUrl: fileUrl || output || '',
remark: remarkText,
});
console.warn(`[Hikvision] 录像行缺失,已兜底插入 completed 行: ${fkColumn}=${taskIdNum}, camera=${cameraIdNum}`);
}
console.log(`[Hikvision] 录像完成: ${fkColumn}=${taskIdNum}, url=${fileUrl}, size=${size}`);
return this.successResponse('hikvision.taskComplete',
{ [fkColumn]: taskIdNum, status: 'completed' }, '录像完成');
} else {
// 录像失败 - 同样按摄像头精准定位最新记录
const latestVideo = await this._findVideoRow(videoTable, fkColumn, taskIdNum, cameraIdNum);
if (latestVideo) {
await app.mysql.get('wms').query(
`UPDATE ${videoTable} SET status = 'failed', remark = ?, updated_at = UTC_TIMESTAMP() WHERE id = ?`,
[errorMsg || '录像失败', latestVideo.id]
);
} else {
await this._insertVideoResult(videoTable, fkColumn, taskIdNum, cameraIdNum, {
status: 'failed',
remark: errorMsg || '录像失败',
});
console.warn(`[Hikvision] 录像行缺失,已兜底插入 failed 行: ${fkColumn}=${taskIdNum}, camera=${cameraIdNum}`);
}
console.log(`[Hikvision] 录像失败: ${fkColumn}=${taskIdNum}, error=${errorMsg}`);
return this.successResponse('hikvision.taskComplete',
{ [fkColumn]: taskIdNum, status: 'failed', error: errorMsg }, '录像失败已记录');
}
} catch (error) {
console.error('[Hikvision] taskComplete 错误:', error);
return this.errorResponse('hikvision.taskComplete', error.message);
}
}
/**
* 强制录制:外部 HTTP 调用,按任务ID强制推送录制任务
* 支持打包(pack_task_id)与拆包(unpack_id + task_type='unpack')
* 事务内重置已有录像行,推送成功后提交
* 下发的 payload 额外带 weight=1 作为强制录制标记
*/
async forceRecord(data) {
const { app } = this;
const { pack_task_id, unpack_id, task_type } = data || {};
// 任务类型判断:task_type 优先;否则按入参 ID 判断
const isUnpack = task_type === 'unpack' || (!pack_task_id && !!unpack_id);
const taskId = isUnpack ? unpack_id : pack_task_id;
if (!taskId) {
return { status: 'fail', message: isUnpack ? '缺少 unpack_id' : '缺少 pack_task_id' };
}
try {
const cfg = this._getTaskCfg(isUnpack ? 'unpack' : 'pack');
// 1. 查询任务(拆包主表无 deleted_at 列)
const getCond = { id: taskId };
if (!isUnpack) getCond.deleted_at = null;
const task = await app.mysql.get('wms').get(cfg.taskTable, getCond);
if (!task) {
return { status: 'fail', message: isUnpack ? '拆包任务不存在' : '打包任务不存在' };
}
if (!task.end_time || !task[cfg.cameraIdsField] || task[cfg.cameraIdsField] === '[]') {
return { status: 'fail', message: '任务未完成或无摄像头信息' };
}
// 2. 查询摄像头和服务器
const cameras = await app.mysql.get('wms').select('wms_camera', {
where: { warehouse_id: task.warehouse_id, deleted_at: null, status: 1 },
});
const servers = await app.mysql.get('wms').select('wms_camera_server', {
where: { warehouse_id: task.warehouse_id, deleted_at: null, status: 1 },
});
// 3. 找到同仓库的录制电脑
const warehousePattern = `warehouse:${task.warehouse_id}:printer:*`;
const onlineKeys = [];
let cursor = '0';
do {
const [nextCursor, keys] = await app.redis.scan(cursor, 'MATCH', warehousePattern, 'COUNT', 100);
cursor = nextCursor;
onlineKeys.push(...keys);
} while (cursor !== '0');
let recordingUniqueId = null;
for (const key of onlineKeys) {
const info = await app.redis.get(key);
if (!info) continue;
const parsed = JSON.parse(info);
if (parsed.is_recording === 1) {
recordingUniqueId = parsed.uniqueId;
break;
}
}
if (!recordingUniqueId) {
console.log(`[Hikvision] forceRecord 失败: 仓库 ${task.warehouse_id} 无录制电脑在线, 在线电脑: ${onlineKeys.length}台`);
return { status: 'fail', message: '该仓库无录制电脑在线' };
}
// 4. 重置录像行(无显式事务):先删旧行,再逐摄像头插入 created 行
const cameraIds = typeof task[cfg.cameraIdsField] === 'string'
? JSON.parse(task[cfg.cameraIdsField]) : (task[cfg.cameraIdsField] || []);
await app.mysql.get('wms').delete(cfg.videoTable, { [cfg.fkColumn]: task.id });
const pushedItems = [];
for (const cameraId of cameraIds) {
let matchedCamera = cameras.find(c => c.id === cameraId);
if (!matchedCamera && cfg.workbenchMatch && task.workbench_id) {
matchedCamera = cameras.find(
c => c.custom_name && c.custom_name.includes(`${task.workbench_id}号`)
);
}
if (!matchedCamera) matchedCamera = cameras[0];
if (!matchedCamera) continue;
const matchedServer = servers.find(s => s.id === matchedCamera.server_id) || servers[0];
if (!matchedServer) continue;
await app.mysql.get('wms').query(
`INSERT INTO ${cfg.videoTable} (${cfg.fkColumn}, camera_id, video_url, status, created_at, updated_at)
VALUES (?, ?, '', 'created', UTC_TIMESTAMP(), UTC_TIMESTAMP())`,
[task.id, matchedCamera.id]
);
pushedItems.push({ cameraId, matchedCamera, matchedServer });
}
console.log(`[Hikvision] 强制录制-重置录像行: ${cfg.fkColumn}=${task.id}`);
// 5. 推送录制任务(推送失败则删除刚插入的行,恢复原状)
for (const { cameraId, matchedCamera, matchedServer } of pushedItems) {
const payload = {
...cfg.buildFields(task, cameraId),
uniqueCode: `${cfg.codePrefix}${task.id}_${cameraId}`,
weight: 1, // 强制录制标记:下发 weight=1 供录制端识别
start_time: this._toISO(task.start_time, -5000),
end_time: this._toISO(task.end_time, cfg.endOffsetMs || 0),
operator: task.operator_text,
camera: {
id: matchedCamera.id,
channel_id: matchedCamera.channel_id,
channel_name: matchedCamera.channel_name,
ip: matchedCamera.ip,
port: matchedCamera.port,
model: matchedCamera.model,
},
server: {
id: matchedServer.id,
brand: matchedServer.brand,
internal_ip: matchedServer.internal_ip,
internal_port: matchedServer.internal_port || 80,
username: matchedServer.username,
password: matchedServer.password,
},
};
const sendRes = await app.ws.sendTo(recordingUniqueId, JSON.stringify({
method: 'hikvision.receiveTask',
data: payload,
}));
if (sendRes !== 1) {
// 推送失败:删除刚插入的行,避免任务卡在 created 状态
await app.mysql.get('wms').delete(cfg.videoTable, { [cfg.fkColumn]: task.id });
return { status: 'fail', message: '推送失败,录制电脑可能已断开' };
}
console.log(`[Hikvision] 强制录制-已推送: ${cfg.fkColumn}=${task.id}, camera=${cameraId}`);
}
return { status: 'success', message: '强制录制任务已推送', [cfg.fkColumn]: task.id };
} catch (error) {
console.error('[Hikvision] forceRecord 错误:', error);
return { status: 'fail', message: error.message };
}
}
}
module.exports = HikvisionService;