packServer/desktop/Services/PlaybackDownloadService.cs
liufumingren 11ebb33966 feat(extension): 插件配置集中管理 + 桌面端策略安装 + 跨网下载修复
- 后端:sys_config 存插件配置(识别前缀/生效站点/模板),平台管理员 GET/PUT /api/web/admin/extension;
  插件读取 GET /api/web/extension/config(Redis 缓存 1 小时,保存即失效)
- 前端:平台管理 → 插件配置页(只维护前缀,单号正则由服务端生成)
- 插件:改为只拉取执行(每 5 分钟 + 手动同步),移除规则编辑/试跑/导入导出;安装包地址自动取最新发布
- 桌面端:工具 → 安装/卸载谷歌插件(生成 .reg + reg import 写 HKLM 策略,读注册表验证);
  跨网下载改走云端中转;局域网探测补排障日志;自动更新按包类型取 md5Exe/sizeExe
- 发布:npm run extension:publish(crx + updates.xml)、extension:zip(商店上传包),
  nginx 对 /download/extension/updates.xml 关缓存

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-01 03:16:26 +08:00

514 lines
20 KiB
C#
Raw Permalink 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.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Edge;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Services;
/// <summary>下载结果(HTTP 接口与桌面端共用)</summary>
/// <param name="Folder">最终存放目录(`{录像根}/yyyy/MM/dd`)</param>
/// <param name="Merged">合并后的成片路径(单路时就是那一路的路径)</param>
/// <param name="Segments">各路段文件(合并失败时才有多个,且都已搬到用户目录)</param>
/// <param name="Warnings">非致命问题(某路没下到等)</param>
public sealed record PlaybackDownloadResult(
string Folder,
string? Merged,
IReadOnlyList<string> Segments,
IReadOnlyList<string> Warnings);
/// <summary>
/// 按 NVR id 取登录凭据。
///
/// 桌面端走用户令牌调后端;后台扫码服务只有设备令牌,走云端下发或本地缓存。
/// 单独抽成委托,是为了让「按流计划下载」这件事不依赖登录态。
/// </summary>
public delegate Task<NvrCredential> NvrCredentialProvider(int nvrId, CancellationToken ct);
/// <summary>
/// 「按运单下载录像」的完整流程(**与界面无关**,桌面端和网页查件都走它)
///
/// 1. `pack-query` 拿到回放计划(扫码当时的工作台快照);
/// 2. 逐路下载到 **临时目录**(并发 2 路,8000 全速拉流优先、失败回落 RTSP);
/// 3. 多路按工作台画布布局**自动合并**成一个视频;
/// 4. 成片放到 `{录像根}/年/月/日/`,删掉临时片段。
///
/// 关键点:**录像存储路径是每台机器自己的设置**,跟"是不是设备服务器"无关 ——
/// 任何装了本机软件的电脑,查件后都能下载到自己配的目录里。
/// </summary>
public sealed class PlaybackDownloadService
{
/// <summary>同时下载几路(给 NVR 回放连接留余量)</summary>
private const int MaxParallel = 2;
private readonly OrderQueryService _query;
private readonly HikPlaybackService _playback;
private readonly Func<ApiClient?> _api;
private readonly Func<int> _subjectId;
private readonly Func<string?> _token;
private readonly Func<string> _root;
/// <summary>选路:有设备管理服务就交给它,没有才本机下载(服务端自身为 null)</summary>
private readonly StreamGateway? _gateway;
public PlaybackDownloadService(
OrderQueryService query,
HikPlaybackService playback,
Func<ApiClient?> apiProvider,
Func<int> subjectIdProvider,
Func<string?> tokenProvider,
Func<string> videoRootProvider,
StreamGateway? gateway = null)
{
_query = query;
_playback = playback;
_api = apiProvider;
_subjectId = subjectIdProvider;
_token = tokenProvider;
_root = videoRootProvider;
_gateway = gateway;
}
/// <summary>
/// 按运单号下载这段时间的录像(多路自动合并)
/// </summary>
/// <exception cref="InvalidOperationException">查询失败 / 没有可下载的流(message 可直接给用户看)</exception>
public async Task<PlaybackDownloadResult> DownloadAsync(string code, IProgress<string>? progress = null,
CancellationToken ct = default)
{
var outcome = await _query.QueryAsync(code, ct).ConfigureAwait(false);
if (!outcome.Http.Ok || outcome.Query is null)
{
throw new InvalidOperationException(outcome.Http.Message);
}
var query = outcome.Query;
if (!query.Playback || query.Records.Count == 0)
{
throw new InvalidOperationException("这个运单没有可下载的回放(扫码时该通道没绑定工作台)");
}
var streams = query.Records.SelectMany(item => item.Streams).ToList();
if (streams.Count == 0)
{
throw new InvalidOperationException("工作台没有绑定摄像头,没有可下载的流");
}
var scanTime = query.Records[0].ScanTime.LocalDateTime;
var nvrs = streams
.Select(item => (Host: item.NvrHost, item.NvrPort))
.Where(item => !string.IsNullOrWhiteSpace(item.Host))
.Distinct()
.ToList();
// 选路(三级):
// ① 局域网有设备管理服务 → 交给它(共用它的 NVR 会话池)
// ② 没有 → 问云端,由能访问 NVR 的仓库设备代取、中转回来
// ③ 云端也不行 → 本机自己连 NVR(仓库内操作员的常规路径)
var peer = _gateway is null
? null
: await _gateway.FindAsync(nvrs, ct).ConfigureAwait(false);
if (peer is not null)
{
var viaEdge = await TryDownloadViaEdgeAsync(peer, code, streams, scanTime, progress, ct)
.ConfigureAwait(false);
if (viaEdge is not null) return viaEdge;
_gateway?.Invalidate();
progress?.Report("设备管理服务执行失败,改由云端中转…");
}
else
{
progress?.Report("局域网没有设备管理服务,改由云端中转…");
}
var viaCloud = await TryDownloadViaCloudAsync(code, scanTime, progress, ct).ConfigureAwait(false);
if (viaCloud is not null) return viaCloud;
progress?.Report("云端也不可用,改由本机直连录像机…");
return await DownloadByPlanAsync(
code,
streams,
scanTime,
_root(),
FetchCredentialAsync,
progress,
ct).ConfigureAwait(false);
}
/// <summary>
/// 跨网下载:**只走云端中转**,不回落本机直连。
///
/// 桌面主窗的「下载录像」在跨网时用它 —— 查询机连不到仓库的 NVR,
/// 本机直连只会让 ffmpeg 报 −138(RTSP 连接超时)。
/// </summary>
/// <exception cref="InvalidOperationException">云端不可用 / 没有在线设备 / 设备代取失败</exception>
public async Task<PlaybackDownloadResult> DownloadViaCloudAsync(string code, DateTime scanTime,
IProgress<string>? progress = null, CancellationToken ct = default)
{
var result = await TryDownloadViaCloudAsync(code, scanTime, progress, ct).ConfigureAwait(false);
if (result is null)
{
throw new InvalidOperationException(
"云端中转不可用(没有在线的扫码服务,或云端任务创建失败,详见上方提示)");
}
return result;
}
/// <summary>
/// 跨公司路径:云端建任务 → 仓库设备拉流并上传 → 本机把成片取回落盘。
///
/// 返回 null 表示「云端不可用/没有在线设备」,调用方降级到本机直连。
/// </summary>
private async Task<PlaybackDownloadResult?> TryDownloadViaCloudAsync(string code, DateTime scanTime,
IProgress<string>? progress, CancellationToken ct)
{
var api = _api?.Invoke();
var token = _token?.Invoke();
var subjectId = _subjectId?.Invoke() ?? 0;
if (api is null || string.IsNullOrWhiteSpace(token) || subjectId <= 0) return null;
string state;
string? taskId;
string? message;
try
{
(state, taskId, message) = await api.EdgeDownloadCreateAsync(token!, subjectId, code, ct)
.ConfigureAwait(false);
}
catch (Exception ex)
{
progress?.Report($"云端建任务失败:{ex.Message}");
return null;
}
if (state != "ok" || string.IsNullOrEmpty(taskId))
{
progress?.Report($"云端无法代取:{message ?? state}");
return null;
}
progress?.Report("仓库设备正在拉流并上传…");
var deadline = DateTime.UtcNow.AddMinutes(15);
var lastState = "";
while (DateTime.UtcNow < deadline)
{
ct.ThrowIfCancellationRequested();
var status = await api.EdgeDownloadStatusAsync(token!, subjectId, taskId, ct).ConfigureAwait(false);
if (status is null) return null;
if (status.State == "failed")
{
throw new InvalidOperationException(status.Error ?? "云端下载失败");
}
if (status.State == "done") break;
if (status.State != lastState)
{
lastState = status.State;
progress?.Report(status.State == "uploading"
? $"正在上传成片({status.Size / 1024.0 / 1024.0:0.0} MB)…"
: "等待仓库设备开始下载…");
}
await Task.Delay(TimeSpan.FromSeconds(1), ct).ConfigureAwait(false);
}
if (lastState != "" && lastState != "done" && DateTime.UtcNow >= deadline)
{
throw new InvalidOperationException("等待云端下载超时(15 分钟)");
}
var folder = VideoStorage.FolderFor(_root(), scanTime);
Directory.CreateDirectory(folder);
var target = Path.Combine(folder, $"{Sanitize(code)}_云端_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在从云端取回成片…");
var size = await api.DownloadEdgeFileAsync(token!, subjectId, taskId!, target, ct).ConfigureAwait(false);
progress?.Report($"已保存:{target}({size / 1024.0 / 1024.0:0.0} MB)");
return new PlaybackDownloadResult(folder, target, new[] { target }, new List<string>());
}
/// <summary>
/// 交给设备管理服务:派任务 → 轮询 → 把成片拉回本机。
///
/// 返回 null 表示「没接单/没完成」,调用方降级到本机直连(保持原有失败语义)。
/// </summary>
private async Task<PlaybackDownloadResult?> TryDownloadViaEdgeAsync(
EdgePeer peer,
string code,
IReadOnlyList<PackStream> streams,
DateTime scanTime,
IProgress<string>? progress,
CancellationToken ct)
{
progress?.Report($"交由设备管理服务 {peer.Display} 执行…");
// 凭据仍从后端取:取流服务那边只有设备令牌,拿不到用户态凭据
var credentials = new List<NvrCredential>();
var seen = new HashSet<int>();
foreach (var stream in streams)
{
if (!seen.Add(stream.NvrId)) continue;
credentials.Add(await FetchCredentialAsync(stream.NvrId, ct).ConfigureAwait(false));
}
using var client = new EdgeClient(peer);
var taskId = await client.CreateDownloadAsync(code, streams, credentials, scanTime, ct)
.ConfigureAwait(false);
if (string.IsNullOrEmpty(taskId))
{
progress?.Report("取流服务拒绝了下载任务");
return null;
}
progress?.Report("取流服务已接单,等待下载与合并…");
var completed = false;
var deadline = DateTime.UtcNow.AddMinutes(15);
while (DateTime.UtcNow < deadline)
{
ct.ThrowIfCancellationRequested();
var status = await client.GetStatusAsync(taskId, ct).ConfigureAwait(false);
if (status is null)
{
progress?.Report("取流服务状态查询失败");
return null;
}
if (status.IsFailed) throw new InvalidOperationException(status.Error ?? "取流服务下载失败");
if (status.IsDone)
{
completed = true;
break;
}
if (!string.IsNullOrEmpty(status.Progress)) progress?.Report(status.Progress);
await Task.Delay(TimeSpan.FromSeconds(2), ct).ConfigureAwait(false);
}
if (!completed) throw new InvalidOperationException("等待取流服务超时(15 分钟)");
var folder = VideoStorage.FolderFor(_root(), scanTime);
Directory.CreateDirectory(folder);
var target = Path.Combine(folder, $"{Sanitize(code)}_取流_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在接收成片…");
var size = await client.DownloadFileAsync(taskId, target, ct).ConfigureAwait(false);
progress?.Report($"已保存:{target}({size / 1024.0 / 1024.0:0.0} MB)");
return new PlaybackDownloadResult(folder, target, new[] { target }, new List<string>());
}
/// <summary>
/// 按**流计划**下载并合并(不查库、不依赖用户令牌)
///
/// 桌面端由 <see cref="DownloadAsync"/> 查好计划再调进来;
/// 后台扫码服务只有设备令牌、调不了 `pack-query`,所以直接调这个。
/// </summary>
/// <param name="rootDir">成片根目录(桌面端用用户设置,服务端用 ProgramData 下的录像目录)</param>
/// <param name="credentialProvider">按 NVR id 取凭据(桌面端走 API,服务端走云端下发或本地缓存)</param>
public async Task<PlaybackDownloadResult> DownloadByPlanAsync(
string code,
IReadOnlyList<PackStream> streams,
DateTime scanTime,
string rootDir,
NvrCredentialProvider credentialProvider,
IProgress<string>? progress = null,
CancellationToken ct = default)
{
if (streams.Count == 0) throw new InvalidOperationException("没有可下载的流");
var folder = VideoStorage.FolderFor(rootDir, scanTime);
Directory.CreateDirectory(folder);
var stamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
var workDir = Path.Combine(Path.GetTempPath(), "YuncangTrace", "playback",
$"{Sanitize(code)}_{stamp}");
Directory.CreateDirectory(workDir);
var warnings = new List<string>();
var saved = new PlaybackClip?[streams.Count];
var gate = new SemaphoreSlim(MaxParallel);
var credentials = new Dictionary<int, NvrCredential>();
var credentialGate = new SemaphoreSlim(1, 1);
try
{
var tasks = new List<Task>();
for (var i = 0; i < streams.Count; i++)
{
var slot = i;
var stream = streams[i];
tasks.Add(Task.Run(async () =>
{
await gate.WaitAsync(ct).ConfigureAwait(false);
try
{
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} 连接中…");
var credential = await CredentialAsync(stream.NvrId, credentials, credentialGate,
credentialProvider, ct).ConfigureAwait(false);
var name = $"{Sanitize(code)}_{stream.CameraId}_{Sanitize(stream.CameraName)}"
+ $"_{stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4";
var path = Path.Combine(workDir, name);
var file = await _playback.DownloadAsync(credential.Host, credential.Port,
credential.Username, credential.Password, stream.ChannelNo,
stream.StartTime, stream.EndTime, path,
new Progress<PlaybackProgress>(p =>
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} {p.Message}")),
ct).ConfigureAwait(false);
saved[slot] = file;
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} ✓ 完成");
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
warnings.Add($"{stream.DisplayName}:{ex.Message}");
progress?.Report($"[{slot + 1}/{streams.Count}] {stream.DisplayName} ✗ {ex.Message}");
}
finally
{
gate.Release();
}
}, ct));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
var parts = new List<(PackStream Stream, PlaybackClip Clip)>();
for (var i = 0; i < streams.Count; i++)
{
if (saved[i] is { } clip) parts.Add((streams[i], clip));
}
if (parts.Count == 0)
{
throw new InvalidOperationException(
"所有通道都没能下载成功:" + string.Join(";", warnings));
}
if (parts.Count == 1)
{
var single = parts[0].Clip.Path;
var target = Path.Combine(folder, Path.GetFileName(single));
if (File.Exists(target)) File.Delete(target);
File.Move(single, target);
progress?.Report($"已保存:{target}");
return new PlaybackDownloadResult(folder, target, new[] { target }, warnings);
}
var merged = Path.Combine(folder,
$"{Sanitize(code)}_合并_{parts[0].Stream.StartTime.ToLocalTime():yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在按工作台布局合并…");
try
{
await _playback.ComposeAsync(
parts.Select(item => item.Clip.Path).ToList(),
parts.Select(item => item.Stream).ToList(),
merged,
parts.Select(item => item.Clip.StartOffset).ToList(),
new Progress<PlaybackProgress>(p => progress?.Report(p.Message)),
ct).ConfigureAwait(false);
progress?.Report($"已合并:{merged}");
return new PlaybackDownloadResult(folder, merged, new[] { merged }, warnings);
}
catch (Exception ex)
{
// 合并失败不丢数据:把各路段搬到用户目录
warnings.Add($"合并失败:{ex.Message}");
var moved = new List<string>();
foreach (var (_, clip) in parts)
{
var target = Path.Combine(folder, Path.GetFileName(clip.Path));
if (File.Exists(target)) File.Delete(target);
File.Move(clip.Path, target);
moved.Add(target);
}
return new PlaybackDownloadResult(folder, null, moved, warnings);
}
}
finally
{
TryDeleteDirectory(workDir);
}
}
/// <summary>按 NVR id 取凭据并缓存(同一份计划里每个 NVR 只取一次)</summary>
private async Task<NvrCredential> CredentialAsync(int nvrId, Dictionary<int, NvrCredential> cache,
SemaphoreSlim gate, NvrCredentialProvider provider, CancellationToken ct)
{
await gate.WaitAsync(ct).ConfigureAwait(false);
try
{
if (cache.TryGetValue(nvrId, out var cached)) return cached;
var credential = await provider(nvrId, ct).ConfigureAwait(false);
if (string.IsNullOrEmpty(credential.Password))
{
throw new InvalidOperationException(
$"录像机「{credential.Name}」没有保存密码,请到网页端「录像机」页补填");
}
cache[nvrId] = credential;
return credential;
}
finally
{
gate.Release();
}
}
/// <summary>桌面端默认实现:带用户令牌调后端拿凭据</summary>
private async Task<NvrCredential> FetchCredentialAsync(int nvrId, CancellationToken ct)
{
var api = _api() ?? throw new InvalidOperationException("本机软件未登录");
var token = _token() ?? throw new InvalidOperationException("本机软件未登录");
return await api.NvrCredentialAsync(token, _subjectId(), nvrId, ct).ConfigureAwait(false);
}
private static string Sanitize(string? text)
{
if (string.IsNullOrEmpty(text)) return "_";
var invalid = Path.GetInvalidFileNameChars();
return new string(text.Select(ch => invalid.Contains(ch) ? '_' : ch).ToArray());
}
private static void TryDeleteDirectory(string dir)
{
try
{
if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
}
catch (Exception ex)
{
AppLog.Write($"[playback] 清理临时目录失败({dir}):{ex.Message}");
}
}
}