2103 lines
107 KiB
C#
2103 lines
107 KiB
C#
using ClockSnowFlake;
|
||
using dy.net.model.dto;
|
||
using dy.net.model.entity;
|
||
using dy.net.model.response;
|
||
using dy.net.service;
|
||
using dy.net.utils;
|
||
using Newtonsoft.Json;
|
||
using Quartz;
|
||
using Quartz.Util;
|
||
using Serilog;
|
||
using System.Net;
|
||
using System.Text;
|
||
using dy.net.storage;
|
||
|
||
namespace dy.net.job
|
||
{
|
||
/// <summary>
|
||
/// 抖音数据同步任务基类
|
||
/// 所有具体的抖音同步任务（如收藏、关注、作品等）都应继承此类
|
||
/// 提供了通用的同步逻辑，如Cookie处理、视频下载、数据存储等
|
||
/// </summary>
|
||
[DisallowConcurrentExecution] // 禁止并发执行，确保同一时间只有一个实例在运行
|
||
public abstract class DouyinBasicSyncJob : IJob, IDisposable
|
||
{
|
||
#region 受保护字段
|
||
|
||
/// <summary>
|
||
/// 抖音Cookie服务，用于获取和管理用户Cookie
|
||
/// </summary>
|
||
protected readonly DouyinCookieService douyinCookieService;
|
||
/// <summary>
|
||
/// 抖音HTTP客户端服务，用于发送HTTP请求
|
||
/// </summary>
|
||
protected readonly DouyinHttpClientService douyinHttpClientService;
|
||
/// <summary>
|
||
/// 抖音视频服务，用于视频信息的数据库操作
|
||
/// </summary>
|
||
protected readonly DouyinVideoService douyinVideoService;
|
||
/// <summary>
|
||
/// 抖音通用服务，用于获取应用配置等
|
||
/// </summary>
|
||
protected readonly DouyinCommonService douyinCommonService;
|
||
protected readonly MediaStorageRouter mediaStorageRouter;
|
||
protected readonly VideoTaskService videoTaskService;
|
||
protected StorageType ActiveStorageType { get; private set; } = StorageType.Local;
|
||
private string _taskId;
|
||
private string _currentTaskItemId;
|
||
private bool _stopCurrentCookie;
|
||
private readonly List<string> _currentItemWarnings = new();
|
||
/// <summary>
|
||
/// 抖音关注列表
|
||
/// </summary>
|
||
private readonly DouyinFollowService douyinFollowService;
|
||
/// <summary>
|
||
/// 图文合成视频
|
||
/// </summary>
|
||
private readonly DouyinMergeVideoService douyinMergeVideoService;
|
||
/// <summary>
|
||
/// 收藏夹、短剧、合集
|
||
/// </summary>
|
||
private readonly DouyinCollectCateService douyinCollectCateService;
|
||
/// <summary>
|
||
/// 随机数生成器，用于生成随机延迟，模拟人类操作
|
||
/// </summary>
|
||
protected readonly Random _random = new Random();
|
||
/// <summary>
|
||
/// 每页请求的视频数量.不可修改
|
||
/// </summary>
|
||
protected string count = "18";
|
||
private bool disposedValue;
|
||
|
||
#endregion
|
||
|
||
#region 私有字段
|
||
|
||
// 类级别静态字段：映射视频类型与同步完成状态判断逻辑（复用+易维护）
|
||
//private static readonly Dictionary<VideoTypeEnum, Func<DouyinCookie, bool>> _syncStatusCheckMap = new()
|
||
//{
|
||
// [VideoTypeEnum.dy_favorite] = cookie => cookie.FavHasSyncd == 1,
|
||
// [VideoTypeEnum.dy_collects] = cookie => cookie.CollHasSyncd == 1,
|
||
// [VideoTypeEnum.dy_follows] = cookie => cookie.UperSyncd == 1,
|
||
// [VideoTypeEnum.ImageVideo] = cookie => cookie.UperSyncd == 1
|
||
// && cookie.CollHasSyncd == 1
|
||
// && cookie.FavHasSyncd == 1
|
||
//};
|
||
|
||
#endregion
|
||
|
||
#region 抽象属性
|
||
|
||
/// <summary>
|
||
/// 同步类型
|
||
/// </summary>
|
||
protected abstract VideoTypeEnum VideoType { get; }
|
||
|
||
#endregion
|
||
|
||
#region 构造函数
|
||
|
||
/// <summary>
|
||
/// 初始化 <see cref="DouyinBasicSyncJob"/> 类的新实例
|
||
/// </summary>
|
||
/// <param name="douyinCookieService">抖音Cookie服务</param>
|
||
/// <param name="douyinHttpClientService">抖音HTTP客户端服务</param>
|
||
/// <param name="douyinVideoService">抖音视频服务</param>
|
||
/// <param name="douyinCommonService">抖音通用服务</param>
|
||
/// <param name="douyinFollowService">抖音关注的</param>
|
||
/// <param name="douyinMergeVideoService">视频合成</param>
|
||
/// <param name="douyinCollectCateService"></param>
|
||
protected DouyinBasicSyncJob(
|
||
DouyinCookieService douyinCookieService,
|
||
DouyinHttpClientService douyinHttpClientService,
|
||
DouyinVideoService douyinVideoService,
|
||
DouyinCommonService douyinCommonService,
|
||
DouyinFollowService douyinFollowService,
|
||
DouyinMergeVideoService douyinMergeVideoService,
|
||
DouyinCollectCateService douyinCollectCateService,
|
||
MediaStorageRouter mediaStorageRouter,
|
||
VideoTaskService videoTaskService)
|
||
{
|
||
this.douyinCookieService = douyinCookieService ?? throw new ArgumentNullException(nameof(douyinCookieService));
|
||
this.douyinHttpClientService = douyinHttpClientService ?? throw new ArgumentNullException(nameof(douyinHttpClientService));
|
||
this.douyinVideoService = douyinVideoService ?? throw new ArgumentNullException(nameof(douyinVideoService));
|
||
this.douyinCommonService = douyinCommonService ?? throw new ArgumentNullException(nameof(douyinCommonService));
|
||
this.douyinFollowService = douyinFollowService;
|
||
this.douyinMergeVideoService = douyinMergeVideoService;
|
||
this.douyinCollectCateService = douyinCollectCateService;
|
||
this.mediaStorageRouter = mediaStorageRouter;
|
||
this.videoTaskService = videoTaskService;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 公共方法
|
||
|
||
/// <summary>
|
||
/// 执行任务的主入口点
|
||
/// 由Quartz调度器调用，负责协调整个同步流程
|
||
/// </summary>
|
||
/// <param name="context">作业执行上下文</param>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
public async Task Execute(IJobExecutionContext context)
|
||
{
|
||
// 获取应用配置
|
||
var config = douyinCommonService.GetConfig();
|
||
ActiveStorageType = config?.StorageType ?? StorageType.Local;
|
||
var (taskId, trigger) = ResolveTaskContext(context.MergedJobDataMap);
|
||
if (string.IsNullOrWhiteSpace(taskId))
|
||
taskId = (await videoTaskService.CreateTaskAsync(VideoTaskType.Sync, trigger,
|
||
$"{VideoType.GetDesc()}同步", VideoType, ActiveStorageType)).Id;
|
||
_taskId = taskId;
|
||
if (!await videoTaskService.IsStorageAvailableAsync())
|
||
{
|
||
await videoTaskService.BlockTaskForStorageAsync(_taskId, "存储不可用，请在任务中心重新检测存储。");
|
||
return;
|
||
}
|
||
await videoTaskService.StartTaskAsync(_taskId);
|
||
string taskError = null;
|
||
try
|
||
{
|
||
// 在处理Cookie之前执行的预处理
|
||
await BeforeProcessCookies();
|
||
|
||
// 获取所有有效的Cookie
|
||
var cookies = await GetSyncCookies();
|
||
if (cookies == null || !cookies.Any())
|
||
{
|
||
Log.Debug($"[{VideoType.GetDesc()}]-Cookie无效或同步开关未开启或对应类型的存储路径未设置，请检查...");
|
||
return;
|
||
}
|
||
Log.Debug($"[{VideoType.GetDesc()}]共发现{cookies.Count}个有效Cookie，同步开始...");
|
||
|
||
// 遍历每个有效的Cookie，执行同步
|
||
foreach (var cookie in cookies)
|
||
{
|
||
if (!await videoTaskService.IsStorageAvailableAsync()) break;
|
||
var sourceAccess = await videoTaskService.GetSourceAccessAsync(cookie.Id);
|
||
if (!sourceAccess.Allowed)
|
||
{
|
||
Log.Warning("[{Cookie}][{Type}]跳过本次同步：{Reason}", cookie.UserName, VideoType.GetDesc(), sourceAccess.Message);
|
||
continue;
|
||
}
|
||
await ProcessSyncUserCookie(cookie, config);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
taskError = ex.GetBaseException().Message;
|
||
Log.Error(ex, "[{Type}]同步任务执行失败，TaskId={TaskId}，Trigger={Trigger}",
|
||
VideoType.GetDesc(), _taskId, trigger);
|
||
throw;
|
||
}
|
||
finally
|
||
{
|
||
await videoTaskService.CompleteTaskAsync(_taskId, taskError);
|
||
}
|
||
}
|
||
|
||
internal static (string TaskId, VideoTaskTrigger Trigger) ResolveTaskContext(JobDataMap jobData)
|
||
{
|
||
string taskId = null;
|
||
string triggerName = null;
|
||
jobData?.TryGetString("video-task-id", out taskId);
|
||
jobData?.TryGetString("video-task-trigger", out triggerName);
|
||
var trigger = string.Equals(triggerName, "manual", StringComparison.OrdinalIgnoreCase)
|
||
? VideoTaskTrigger.Manual
|
||
: VideoTaskTrigger.Scheduled;
|
||
return (taskId, trigger);
|
||
}
|
||
|
||
internal static bool ShouldReplaceOldStorageRecord(DouyinVideo existing, StorageType activeStorageType) =>
|
||
activeStorageType.IsRemote() && existing != null && existing.StorageType != activeStorageType;
|
||
|
||
#endregion
|
||
|
||
#region 受保护方法
|
||
|
||
/// <summary>
|
||
/// 在处理Cookie之前执行的预处理操作-AOP
|
||
/// </summary>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
protected virtual Task BeforeProcessCookies() => Task.CompletedTask;
|
||
|
||
/// <summary>
|
||
/// 获取所有有效的Cookie
|
||
/// 子类必须实现此方法，根据具体任务类型筛选有效的Cookie
|
||
/// </summary>
|
||
/// <returns>有效的Cookie列表</returns>
|
||
protected virtual async Task<List<DouyinCookie>> GetSyncCookies()
|
||
{
|
||
var cookies = await douyinCookieService.GetOpendCookiesAsync();
|
||
return cookies.Where(x => !string.IsNullOrWhiteSpace(GetStorageRoot(x, VideoType))).ToList();
|
||
}
|
||
|
||
protected string GetStorageRoot(DouyinCookie cookie, VideoTypeEnum type)
|
||
{
|
||
if (ActiveStorageType.IsRemote())
|
||
return StorageMigrationPathPolicy.GetRemoteRoot(cookie, type);
|
||
|
||
return type switch
|
||
{
|
||
VideoTypeEnum.dy_favorite => cookie.FavSavePath,
|
||
VideoTypeEnum.dy_follows => cookie.UpSavePath,
|
||
VideoTypeEnum.dy_mix => string.IsNullOrWhiteSpace(cookie.MixPath) ? cookie.SavePath : cookie.MixPath,
|
||
VideoTypeEnum.dy_series => string.IsNullOrWhiteSpace(cookie.SeriesPath) ? cookie.SavePath : cookie.SeriesPath,
|
||
_ => cookie.SavePath
|
||
};
|
||
}
|
||
|
||
protected string CombineStoragePath(params string[] parts) => ActiveStorageType.IsRemote()
|
||
? StoragePath.CombineRemote(parts)
|
||
: Path.Combine(parts);
|
||
|
||
protected void EnsureStorageDirectory(string path)
|
||
{
|
||
if (ActiveStorageType == StorageType.Local && !Directory.Exists(path)) Directory.CreateDirectory(path);
|
||
}
|
||
|
||
protected StorageMigrationPathPlan BuildRemotePathPlan(
|
||
DouyinCookie cookie,
|
||
Aweme item,
|
||
AppConfig config,
|
||
DouyinFollowed followed,
|
||
DouyinCollectCate cate) =>
|
||
StorageMigrationPathPolicy.Build(item, VideoType, cookie, cate, followed, config);
|
||
|
||
private static string CreateTemporaryDirectory()
|
||
{
|
||
var directory = Path.Combine(Path.GetTempPath(), "dysync", Guid.NewGuid().ToString("N"));
|
||
Directory.CreateDirectory(directory);
|
||
return directory;
|
||
}
|
||
|
||
private async Task<string> UploadLocalFileAsync(string localPath, string remotePath)
|
||
{
|
||
var storage = mediaStorageRouter.Resolve(ActiveStorageType);
|
||
if (storage is ICanonicalMediaStorage canonicalStorage)
|
||
remotePath = await canonicalStorage.CanonicalizePathAsync(remotePath);
|
||
await using var input = new FileStream(localPath, FileMode.Open, FileAccess.Read, FileShare.Read, 81920, true);
|
||
await storage.WriteAsync(remotePath, input, input.Length, null);
|
||
return remotePath;
|
||
}
|
||
|
||
private async Task<IReadOnlyDictionary<string, string>> UploadDirectoryAsync(string localRoot, string remoteRoot)
|
||
{
|
||
var uploaded = new Dictionary<string, string>(StringComparer.Ordinal);
|
||
foreach (var file in Directory.EnumerateFiles(localRoot, "*", SearchOption.AllDirectories))
|
||
{
|
||
var relative = Path.GetRelativePath(localRoot, file).Replace('\\', '/');
|
||
uploaded[relative] = await UploadLocalFileAsync(file, StoragePath.CombineRemote(remoteRoot, relative));
|
||
}
|
||
return uploaded;
|
||
}
|
||
|
||
private static void CleanupTemporaryDirectory(string path)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(path) || !Directory.Exists(path)) return;
|
||
try { Directory.Delete(path, true); }
|
||
catch (Exception ex) { Log.Warning(ex, "清理临时目录失败：{Path}", path); }
|
||
}
|
||
|
||
private async Task WriteRemoteNfoAsync(AppConfig config, DouyinVideo video, DouyinCollectCate cate)
|
||
{
|
||
if (config.CloseNfo || !video.StorageType.IsRemote()) return;
|
||
foreach (var file in NfoContentBuilder.Build(video, cate?.Name))
|
||
{
|
||
var bytes = Encoding.UTF8.GetBytes(file.Value);
|
||
await using var content = new MemoryStream(bytes, false);
|
||
await mediaStorageRouter.Resolve(video.StorageType).WriteAsync(file.Key, content, bytes.Length, "application/xml");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据Cookie和游标获取视频数据
|
||
/// 子类必须实现此方法，调用具体的API接口获取视频列表
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="cursor">分页游标，用于获取下一页数据</param>
|
||
/// <param name="followed">关注的人</param>
|
||
/// <param name="cate">自定义收藏夹、合集、短剧</param>
|
||
/// <returns>视频信息对象，包含视频列表和分页信息</returns>
|
||
protected abstract Task<DouyinVideoInfoResponse> FetchVideoData(DouyinCookie cookie, string cursor, DouyinFollowed followed, DouyinCollectCate cate);
|
||
|
||
|
||
/// <summary>
|
||
/// 获取下一页数据的游标
|
||
/// </summary>
|
||
/// <param name="data">当前获取到的视频数据</param>
|
||
/// <returns>下一页数据的游标</returns>
|
||
private static string GetNextCursor(DouyinVideoInfoResponse data)
|
||
{
|
||
return data?.Cursor ?? (data?.MaxCursor ?? "0");
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 创建视频保存文件夹
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="item">视频信息</param>
|
||
/// <param name="followed">关注用户</param>
|
||
/// <param name="cate"></param>
|
||
/// <param name="config">应用配置</param>
|
||
/// <returns>创建的视频保存文件夹路径</returns>
|
||
protected virtual string CreateSaveFolder(DouyinCookie cookie, Aweme item, AppConfig config, DouyinFollowed followed, DouyinCollectCate cate)
|
||
{
|
||
if (ActiveStorageType.IsRemote())
|
||
return BuildRemotePathPlan(cookie, item, config, followed, cate).DirectoryPath;
|
||
var subFolder = DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId, true);
|
||
var root = GetStorageRoot(cookie, VideoType);
|
||
var folder = CombineStoragePath(root, subFolder);
|
||
if (!Directory.Exists(folder))
|
||
{
|
||
Directory.CreateDirectory(folder);
|
||
}
|
||
else
|
||
{
|
||
//说明文件夹存在，检查里面有没有文件，如果已经有视频文件了，说明视频标题相同，那么应该重新创建文件夹,+id
|
||
|
||
folder = CombineStoragePath(root, subFolder + "_" + item.AwemeId);
|
||
}
|
||
return folder;
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取视频文件名,默认就用id作文件名
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="item">视频信息</param>
|
||
/// <param name="config">配置信息</param>
|
||
/// <param name="cate"></param>
|
||
/// <returns>生成的视频文件名</returns>
|
||
protected virtual string GetVideoFileName(DouyinCookie cookie, Aweme item, AppConfig config, DouyinCollectCate cate)
|
||
{
|
||
if (ActiveStorageType.IsRemote())
|
||
return Path.GetFileName(BuildRemotePathPlan(cookie, item, config, null, cate).VideoPath);
|
||
if (cate != null && cate.CateType == VideoTypeEnum.dy_custom_collect)
|
||
{
|
||
if (item.Video != null && item.Video.BitRate != null)
|
||
return $"{item.AwemeId}.{item.Video.BitRate.FirstOrDefault().Format}";
|
||
return $"{item.AwemeId}.mp4";
|
||
}
|
||
else
|
||
{
|
||
if ((VideoType == VideoTypeEnum.dy_series || VideoType == VideoTypeEnum.dy_mix) && item.MixInfo?.Statis?.CurrentEpisode != null)
|
||
{
|
||
// 第一步：将 CurrentEpisode 转换为整数（兼容字符串/数字类型）
|
||
if (int.TryParse(item.MixInfo.Statis.CurrentEpisode.ToString(), out int episodeNum))
|
||
{
|
||
// 第二步：格式化数字，确保 1-9 补 0，10+ 保持原样
|
||
string episodeStr = episodeNum.ToString("D2");
|
||
return $"S01E{episodeStr}.mp4";
|
||
}
|
||
// 容错：如果转换失败，使用原始值（避免程序报错）
|
||
return $"S01E{item.MixInfo.Statis.CurrentEpisode}.mp4";
|
||
}
|
||
else
|
||
{
|
||
string Format = "mp4";
|
||
string FileHash = "";
|
||
string Height = "";
|
||
string Width = "";
|
||
|
||
if (item.Video != null && item.Video.BitRate != null)
|
||
{
|
||
var bitrate = item.Video.BitRate.FirstOrDefault();
|
||
Format = bitrate.Format;
|
||
FileHash = bitrate.PlayAddr.FileHash;
|
||
Height = bitrate.PlayAddr.Height.ToString();
|
||
Width = bitrate.PlayAddr.Width.ToString();
|
||
}
|
||
else
|
||
{
|
||
//图片合成视频，参数要自己写。
|
||
var image = item.Images?.FirstOrDefault();
|
||
if (image != null)
|
||
{
|
||
FileHash = IdGener.GetGuid().ToLower().Replace("-", "");//使用随机值，避免重复
|
||
Height = image.Height.ToString();
|
||
Width = image.Width.ToString();
|
||
}
|
||
}
|
||
|
||
|
||
string fileName;
|
||
//if (config?.UperUseViedoTitle ?? false)//优先
|
||
//{
|
||
// var sampleName = DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId);
|
||
// var (existingName, _) = douyinVideoService.GetUperLastViedoFileName(item.Author.Uid, sampleName);
|
||
// fileName = string.IsNullOrWhiteSpace(existingName) ? $"{sampleName}.{Format}" : $"{existingName}.{Format}";
|
||
//}
|
||
//else
|
||
//{
|
||
|
||
if (!string.IsNullOrWhiteSpace(config.FullFollowedTitleTemplate))
|
||
{
|
||
var fullName = VideoTitleGenerator.Generate(config.FullFollowedTitleTemplate, new VideoTitleDataTemplate
|
||
{
|
||
FileHash = FileHash,
|
||
Id = item.AwemeId,
|
||
ReleaseTime = DateTimeUtil.Convert10BitTimestamp(item.CreateTime),
|
||
Resolution = $"{Width}×{Height}",
|
||
VideoTitle = DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId),
|
||
Author = item.Author.Nickname
|
||
});
|
||
|
||
fileName = $"{fullName}.{Format}";
|
||
}
|
||
else
|
||
{
|
||
fileName = $"{item.AwemeId}.{Format}";
|
||
}
|
||
//}
|
||
return fileName;
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 获取作者头像保存的基础路径
|
||
/// 子类必须实现此方法，指定头像的存储位置
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <returns>作者头像保存的基础路径</returns>
|
||
protected abstract string GetAuthorAvatarBasePath(DouyinCookie cookie);
|
||
|
||
/// <summary>
|
||
/// 处理同步完成后的操作
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="syncCount">本次同步成功的视频数量</param>
|
||
/// <param name="followed"></param>
|
||
/// <param name="cate"></param>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
protected async Task HandleSyncCompletion(DouyinCookie cookie, int syncCount, DouyinFollowed followed = null, DouyinCollectCate cate = null)
|
||
{
|
||
var tag = cate?.Name ?? followed?.UperName ?? string.Empty;
|
||
tag = !string.IsNullOrWhiteSpace(tag) ? $"-[{tag}]" : tag;
|
||
|
||
if (VideoType != VideoTypeEnum.dy_custom_collect || cookie.UseCollectFolder)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]{tag},本次成功同步{syncCount}条视频");
|
||
}
|
||
|
||
if (cate != null)
|
||
{
|
||
//更新合集短剧完结状态
|
||
await douyinCollectCateService.UpdateCate2EndStatus(cate);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 处理单个用户Cookie的同步逻辑
|
||
/// 负责循环获取视频数据、处理视频、保存视频信息等
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="config">应用配置</param>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
protected async Task ProcessSyncUserCookie(DouyinCookie cookie, AppConfig config)
|
||
{
|
||
_stopCurrentCookie = false;
|
||
switch (VideoType)
|
||
{
|
||
case VideoTypeEnum.dy_follows:
|
||
if (cookie.DownFollowd)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]开始同步...");
|
||
// 查询关注列表开启了同步的关注。单个博主失败不能阻断后续博主。
|
||
var follows = await douyinFollowService.GetSyncFollows(cookie.MyUserId);
|
||
if (follows != null && follows.Any())
|
||
{
|
||
var failures = new List<string>();
|
||
var consecutiveFailures = 0;
|
||
for (var index = 0; index < follows.Count; index++)
|
||
{
|
||
var followed = follows[index];
|
||
if (_stopCurrentCookie) break;
|
||
try
|
||
{
|
||
int syncCount = 0; // 本次同步成功的视频数量
|
||
string cursor = "0";
|
||
bool hasMore = true;
|
||
(syncCount, cursor, hasMore) = await GetAndSaveViedos(cookie, config, syncCount, cursor, hasMore, followed);
|
||
await HandleSyncCompletion(cookie, syncCount, followed);
|
||
consecutiveFailures = 0;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
consecutiveFailures++;
|
||
var reason = ex.GetBaseException().Message;
|
||
failures.Add($"{followed?.UperName ?? followed?.SecUid ?? "未知博主"}：{reason}");
|
||
Log.Error(ex, "[{Cookie}][{Type}][{Author}]获取或处理作品失败，继续下一个博主",
|
||
cookie.UserName, VideoType.GetDesc(), followed?.UperName ?? followed?.SecUid);
|
||
if (consecutiveFailures >= 3)
|
||
{
|
||
var remaining = follows.Count - index - 1;
|
||
failures.Add($"连续 3 个博主获取失败，本轮提前结束，尚有 {remaining} 个博主未扫描");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (failures.Count > 0)
|
||
throw new InvalidOperationException(
|
||
$"关注作品扫描有异常：{string.Join("；", failures.Take(4))}" +
|
||
(failures.Count > 4 ? $"；另有 {failures.Count - 4} 项" : string.Empty));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]同步未开启");
|
||
}
|
||
break;
|
||
case VideoTypeEnum.dy_favorite:
|
||
if (cookie.DownFavorite)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]开始同步...");
|
||
int syncCount = 0;
|
||
string cursor = "0";
|
||
bool hasMore = true;
|
||
(syncCount, cursor, hasMore) = await GetAndSaveViedos(cookie, config, syncCount, cursor, hasMore);
|
||
await HandleSyncCompletion(cookie, syncCount);
|
||
}
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]同步未开启");
|
||
}
|
||
break;
|
||
case VideoTypeEnum.dy_collects:
|
||
if (cookie.UseCollectFolder)
|
||
{
|
||
Log.Debug($"[{VideoType.GetDesc()}]-已开启自定义收藏夹同步...break;");
|
||
}
|
||
else if (cookie.DownCollect)
|
||
{
|
||
int syncCount = 0;
|
||
string cursor = "0";
|
||
bool hasMore = true;
|
||
(syncCount, cursor, hasMore) = await GetAndSaveViedos(cookie, config, syncCount, cursor, hasMore);
|
||
await HandleSyncCompletion(cookie, syncCount);
|
||
}
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]同步未开启");
|
||
}
|
||
break;
|
||
|
||
case VideoTypeEnum.dy_mix:
|
||
if (cookie.DownMix)
|
||
{
|
||
await SyncCustomListVideos(cookie, config);
|
||
}
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]同步未开启");
|
||
}
|
||
break;
|
||
case VideoTypeEnum.dy_series:
|
||
if (cookie.DownSeries)
|
||
await SyncCustomListVideos(cookie, config);
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]同步未开启");
|
||
}
|
||
break;
|
||
case VideoTypeEnum.dy_custom_collect:
|
||
if (cookie.UseCollectFolder)
|
||
await SyncCustomListVideos(cookie, config);
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]同步未开启");
|
||
}
|
||
break;
|
||
case VideoTypeEnum.ImageVideo:
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 同步下载自定义收藏夹、合集、短剧
|
||
/// </summary>
|
||
/// <param name="cookie"></param>
|
||
/// <param name="config"></param>
|
||
/// <returns></returns>
|
||
private async Task SyncCustomListVideos(DouyinCookie cookie, AppConfig config)
|
||
{
|
||
var cates = await douyinCollectCateService.GetSyncCates(cookie.Id, VideoType);
|
||
if (cates != null && cates.Any())
|
||
{
|
||
foreach (var cate in cates)
|
||
{
|
||
if (_stopCurrentCookie) break;
|
||
int syncCount = 0; // 本次同步成功的视频数量
|
||
string cursor = "0";
|
||
bool hasMore = true;
|
||
(syncCount, cursor, hasMore) = await GetAndSaveViedos(cookie, config, syncCount, cursor, hasMore, null, cate);
|
||
await HandleSyncCompletion(cookie, syncCount, null, cate);
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Serilog.Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]没有查询到已开启的对象");
|
||
}
|
||
}
|
||
|
||
private async Task<(int syncCount, string cursor, bool hasMore)> GetAndSaveViedos(DouyinCookie cookie, AppConfig config, int syncCount, string cursor, bool hasMore, DouyinFollowed followed = null, DouyinCollectCate cate = null)
|
||
{
|
||
// 循环获取视频数据
|
||
while (hasMore && !_stopCurrentCookie)
|
||
{
|
||
// 获取视频数据
|
||
var data = await FetchVideoData(cookie, cursor, followed, cate);
|
||
if (data == null || data.AwemeList == null || !data.AwemeList.Any())
|
||
{
|
||
Serilog.Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}][{cate?.Name}] 没有新的视频");
|
||
break;
|
||
}
|
||
|
||
if (data.StatusCode == 0 && cookie.StatusMsg != "正常")
|
||
{
|
||
cookie.StatusCode = data.StatusCode;
|
||
cookie.StatusMsg = "正常";
|
||
await douyinCookieService.UpdateAsync(cookie);
|
||
}
|
||
// 判断是否还有更多数据
|
||
//hasMore = ShouldContinueSync(cookie, data, followed, config);
|
||
|
||
// 获取下一页游标
|
||
cursor = GetNextCursor(data);
|
||
|
||
hasMore = data.HasMore == 1;
|
||
|
||
// 处理视频列表
|
||
(List<DouyinVideo> videos, int syncCountx) = await ProcessVideoList(syncCount, cookie, data, config, followed, cate);
|
||
if (videos != null && videos.Any())
|
||
{
|
||
// 保存视频信息到数据库
|
||
await SaveVideos(cookie, videos);
|
||
videos.Clear();
|
||
}
|
||
|
||
syncCount += syncCountx;
|
||
|
||
if (IsSyncLimitReached(cookie, config, syncCount, cate, followed))
|
||
{
|
||
break;
|
||
}
|
||
//随机等待
|
||
await Task.Delay(_random.Next(2, 10) * 1000);
|
||
}
|
||
|
||
return (syncCount, cursor, hasMore);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 检查是否达到同步批次上限且满足状态条件，需要终止循环
|
||
/// </summary>
|
||
/// <param name="cookie">抖音Cookie</param>
|
||
/// <param name="config">同步配置</param>
|
||
/// <param name="syncCount">已同步数量</param>
|
||
/// <param name="cate"></param>
|
||
/// <param name="followed"></param>
|
||
/// <returns>是否需要终止循环</returns>
|
||
private bool IsSyncLimitReached(DouyinCookie cookie, AppConfig config, int syncCount, DouyinCollectCate cate, DouyinFollowed followed)
|
||
{
|
||
if (cate != null && cate.CateType != VideoTypeEnum.dy_custom_collect)
|
||
{
|
||
if (syncCount >= 30)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]:本次同步数量{syncCount}，等下次任务继续同步");
|
||
return true;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
if (syncCount >= config.BatchCount)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]:本次同步数量{syncCount}，已达配置上限{config.BatchCount}，等下次任务继续同步");
|
||
return true;
|
||
}
|
||
|
||
}
|
||
if (VideoType == VideoTypeEnum.dy_collects || VideoType == VideoTypeEnum.dy_favorite)
|
||
return config.OnlySyncNew;
|
||
|
||
return VideoType == VideoTypeEnum.dy_follows && !followed.FullSync;
|
||
|
||
//// 获取当前视频类型对应的状态判断逻辑
|
||
//if (!_syncStatusCheckMap.TryGetValue(VideoType, out var isSyncCompleted))
|
||
//{
|
||
// //Log.Debug($"[{VideoType.GetVideoTypeDesc()}]无匹配的同步状态判断规则，不终止循环");
|
||
// return false;
|
||
//}
|
||
|
||
//// 状态满足则记录日志并返回「终止循环」
|
||
//if (isSyncCompleted.Invoke(cookie))
|
||
//{
|
||
// Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]本次同步达到上限{config.BatchCount}，停止同步!!!");
|
||
// return true;
|
||
//}
|
||
|
||
}
|
||
/// <summary>
|
||
/// 遍历视频列表，分别处理每个视频和图片集
|
||
/// </summary>
|
||
/// <param name="syncCount1"></param>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="data">视频信息对象</param>
|
||
/// <param name="config">应用配置</param>
|
||
/// <param name="followed">关注的</param>
|
||
/// <param name="cate">收藏夹、合集、短剧</param>
|
||
/// <returns>处理后的视频实体列表</returns>
|
||
protected async Task<(List<DouyinVideo> videos, int currentCount)> ProcessVideoList(int syncCount1, DouyinCookie cookie, DouyinVideoInfoResponse data, AppConfig config, DouyinFollowed followed = null, DouyinCollectCate cate = null)
|
||
{
|
||
int syncCount = 0;
|
||
var videos = new List<DouyinVideo>();
|
||
foreach (var item in data.AwemeList)
|
||
{
|
||
// Stop promptly once the shared storage circuit opens. Pending work is retained in the
|
||
// task center and can be retried after an explicit successful storage probe.
|
||
if (!await videoTaskService.IsStorageAvailableAsync()) break;
|
||
if (_stopCurrentCookie) break;
|
||
_currentTaskItemId = null;
|
||
_currentItemWarnings.Clear();
|
||
var trackedAwemeId = string.IsNullOrWhiteSpace(item?.AwemeId)
|
||
? $"unknown-{Guid.NewGuid():N}"
|
||
: item.AwemeId;
|
||
try
|
||
{
|
||
//if (item.AwemeId != "7321309610927770930")
|
||
//{
|
||
// continue;
|
||
//}
|
||
//if (!item.Desc.Contains("抖音各种隐藏功能，每个都好用到离谱#抖音#隐藏功能"))
|
||
//{
|
||
// continue;
|
||
//}
|
||
|
||
//判断视频是否是强制删除且不再下载的视频
|
||
var deleteVideo = await douyinCommonService.GetDeleteVideoAsync(item.AwemeId);
|
||
if (deleteVideo != null)
|
||
{
|
||
await videoTaskService.MarkSkippedAsync(_taskId, item.AwemeId, cookie.Id, cookie.UserName, VideoType,
|
||
item.Desc, item.Author?.Nickname, VideoTaskSkipReason.PermanentlyExcluded,
|
||
"视频已被永久排除，可在任务中心取消排除。", deleteVideo.Id);
|
||
continue;
|
||
}
|
||
|
||
// 查询数据库中是否已存在该视频（通过 AwemeId 唯一标识）
|
||
var exitVideo = await douyinVideoService.GetByAwemeId(item.AwemeId);
|
||
var replaceOldStorage = ShouldReplaceOldStorageRecord(exitVideo, ActiveStorageType);
|
||
|
||
// 当前远端存储与现有记录不一致时，不能让普通去重阻止存储收敛。
|
||
// 旧记录和旧文件会一直保留到新媒体写入、校验和数据库提交全部成功之后。
|
||
bool Goon = replaceOldStorage || await AutoDistinct(config, exitVideo, cookie);
|
||
if (!Goon)
|
||
{
|
||
await videoTaskService.MarkSkippedAsync(_taskId, item.AwemeId, cookie.Id, cookie.UserName, VideoType,
|
||
item.Desc, item.Author?.Nickname, VideoTaskSkipReason.Deduplicated, "已存在更高或相同优先级的视频记录。");
|
||
continue;
|
||
}
|
||
|
||
if (exitVideo != null)
|
||
{
|
||
if (replaceOldStorage)
|
||
{
|
||
Log.Debug("[{Cookie}][{Type}]作品 {AwemeId} 位于 {OldStorage}，本次同步将安全替换到 {NewStorage}。",
|
||
cookie.UserName, VideoType.GetDesc(), item.AwemeId, exitVideo.StorageType, ActiveStorageType);
|
||
}
|
||
//文件存在
|
||
else if (await mediaStorageRouter.Resolve(exitVideo.StorageType).ExistsAsync(exitVideo.VideoSavePath))
|
||
{
|
||
//如果当前时正在下载关注列表的视频，但是已经存在合集下载过了，那么跳过
|
||
if (VideoType == VideoTypeEnum.dy_follows && exitVideo.ViedoType == VideoTypeEnum.dy_mix)
|
||
{
|
||
await videoTaskService.MarkSkippedAsync(_taskId, item.AwemeId, cookie.Id, cookie.UserName, VideoType,
|
||
item.Desc, item.Author?.Nickname, VideoTaskSkipReason.AlreadyExists, "合集版本已存在，关注同步已跳过。");
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
//如果当前正在下载合集视频，但是发现已经存在了，但视频类型不是合集，那么删掉原来的记录以及文件，重新下载，合集优先级最高
|
||
if (VideoType == VideoTypeEnum.dy_mix && exitVideo.ViedoType != VideoTypeEnum.dy_mix)
|
||
{
|
||
if (exitVideo.StorageType.IsRemote())
|
||
await StorageArtifactCleaner.DeleteWebDavArtifactsAsync(
|
||
mediaStorageRouter.Resolve(exitVideo.StorageType), exitVideo);
|
||
else
|
||
await mediaStorageRouter.Resolve(StorageType.Local).DeleteAsync(exitVideo.VideoSavePath);
|
||
await douyinVideoService.DeleteById(exitVideo.Id);
|
||
}
|
||
else
|
||
{
|
||
await douyinVideoService.DeleteById(exitVideo.Id);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//2026-06-16 21:56:40 bug修复 ，之前会一直重复下载这个图片
|
||
//判断如果文件路径="/" 说明是仅下载图片的记录，不处理，直接跳过也不用删除记录
|
||
if(exitVideo.VideoUrl=="/"&& exitVideo.IsMergeVideo == 1)
|
||
{
|
||
await videoTaskService.MarkSkippedAsync(_taskId, item.AwemeId, cookie.Id, cookie.UserName, VideoType,
|
||
item.Desc, item.Author?.Nickname, VideoTaskSkipReason.AlreadyExists, "仅图片或音频记录已存在。");
|
||
continue;
|
||
}
|
||
//文件不存在，直接删掉原始记录
|
||
await douyinVideoService.DeleteById(exitVideo.Id);
|
||
}
|
||
}
|
||
|
||
var uper = await douyinFollowService.GetByUperId(item.AuthorUserId.ToString(), cookie.MyUserId);
|
||
if (uper != null && uper.FullSync)
|
||
{
|
||
followed ??= uper;
|
||
}
|
||
var selectedBitRate = GetBestMatchedVideoUrl(item, config);
|
||
var sourceUrls = GetMediaCandidates(item, selectedBitRate);
|
||
var trackedItem = await videoTaskService.AddItemAsync(_taskId, item.AwemeId, cookie.Id, cookie.UserName,
|
||
VideoType, item.Desc, item.Author?.Nickname, sourceUrls: sourceUrls,
|
||
expectedLength: item.Video?.BitRate?.FirstOrDefault()?.PlayAddr?.DataSize ?? 0);
|
||
_currentTaskItemId = trackedItem.Id;
|
||
var sourceAccess = await videoTaskService.TryAcquireSourceAsync(cookie.Id, trackedItem.Id);
|
||
if (!sourceAccess.Allowed)
|
||
{
|
||
await videoTaskService.WaitItemForSourceAsync(trackedItem.Id, cookie.Id, sourceAccess.Message);
|
||
_stopCurrentCookie = true;
|
||
_currentTaskItemId = null;
|
||
break;
|
||
}
|
||
// 处理单个视频
|
||
DouyinVideo video;
|
||
try { video = await ProcessSingleVideo(cookie, item, config, followed, cate, replaceOldStorage ? exitVideo : null); }
|
||
catch (Exception ex)
|
||
{
|
||
await videoTaskService.MarkFailedAsync(_currentTaskItemId, ex);
|
||
Log.Error(ex, "[{Cookie}][{Type}]处理视频失败：{AwemeId}", cookie.UserName, VideoType.GetDesc(), item.AwemeId);
|
||
continue;
|
||
}
|
||
if (video != null)
|
||
{
|
||
if (replaceOldStorage) video.SupersededStorageSnapshot = exitVideo;
|
||
videos.Add(video);
|
||
syncCount++;
|
||
|
||
if (syncCount + syncCount1 >= config.BatchCount)
|
||
{
|
||
return (videos, syncCount);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (string.IsNullOrWhiteSpace(_currentTaskItemId)) continue;
|
||
//处理多个视频-组合的图文视频--类似动图。
|
||
List<DouyinMergeVideoDto> dynamicVideoUrls = new List<DouyinMergeVideoDto>();
|
||
// 当需要下载动态视频时，获取其他URL
|
||
if (config.DownDynamicVideo && item.Images != null && item.Images.Count > 0)
|
||
{
|
||
foreach (var img in item.Images)
|
||
{
|
||
if (img.DynamicVideo?.BitRate?.Count > 0)
|
||
{
|
||
foreach (var btv in img.DynamicVideo.BitRate)
|
||
{
|
||
var targetUrl = btv.PlayAddr?.UrlList?.FirstOrDefault(x => x.StartsWith("https://www.douyin.com/aweme/v1/play"));
|
||
if (targetUrl != null)
|
||
{
|
||
var height = btv.PlayAddr?.Height ?? 1920;
|
||
var width = btv.PlayAddr?.Width ?? 1080;
|
||
DouyinMergeVideoDto info = new DouyinMergeVideoDto
|
||
{
|
||
Path = targetUrl,
|
||
Height = height,
|
||
Width = width
|
||
};
|
||
dynamicVideoUrls.Add(info);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理核心逻辑
|
||
if (dynamicVideoUrls.Count > 0)
|
||
{
|
||
// 处理动态视频
|
||
var dynamicVideo = await ProcessDynamicVideo(dynamicVideoUrls, cookie, item, config, followed, cate);
|
||
if (dynamicVideo != null)
|
||
{
|
||
try
|
||
{
|
||
var remoteReady = dynamicVideo.StorageType == StorageType.Local;
|
||
if (!string.IsNullOrEmpty(dynamicVideo.DynamicVideos))
|
||
{
|
||
var dynamicVideos = JsonConvert.DeserializeObject<List<DouyinMergeVideoDto>>(dynamicVideo.DynamicVideos);
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]-动态视频[{item.Desc}]，下载成功 ,共{dynamicVideos?.Count}个视频...");
|
||
if (dynamicVideos != null && dynamicVideos.Count > 0)
|
||
{
|
||
|
||
var savePath = DouyinFileNameHelper.RemoveNumberSuffix(dynamicVideo.VideoSavePath);
|
||
|
||
//音频文件下载地址
|
||
var mp3Url = item?.Music?.PlayUrl?.UrlList?.FirstOrDefault();
|
||
|
||
|
||
var (mp4Path, mp3Path) = await douyinMergeVideoService.MergeMultipleVideosAsync(dynamicVideos, mp3Url, savePath, cookie.Cookies);
|
||
if (!string.IsNullOrWhiteSpace(mp4Path) && File.Exists(mp4Path))
|
||
{
|
||
if (dynamicVideo.StorageType.IsRemote())
|
||
{
|
||
dynamicVideo.PendingStoragePath = await UploadLocalFileAsync(mp4Path, dynamicVideo.PendingStoragePath);
|
||
dynamicVideo.FileSize = new FileInfo(mp4Path).Length;
|
||
dynamicVideo.VideoSavePath = dynamicVideo.PendingStoragePath;
|
||
if (config.KeepDynamicVideo)
|
||
{
|
||
var remoteParts = new List<DouyinMergeVideoDto>();
|
||
foreach (var part in dynamicVideos.Where(x => File.Exists(x.Path)))
|
||
{
|
||
var remotePart = dynamicVideo.PendingStoragePath.Replace(".mp4", $"-{Path.GetFileName(part.Path)}");
|
||
remotePart = await UploadLocalFileAsync(part.Path, remotePart);
|
||
remoteParts.Add(new DouyinMergeVideoDto { Path = remotePart, Height = part.Height, Width = part.Width });
|
||
}
|
||
dynamicVideo.DynamicVideos = JsonConvert.SerializeObject(remoteParts);
|
||
}
|
||
else
|
||
{
|
||
dynamicVideo.DynamicVideos = null;
|
||
}
|
||
remoteReady = true;
|
||
}
|
||
else
|
||
{
|
||
dynamicVideo.VideoSavePath = mp4Path;
|
||
}
|
||
if (!config.KeepDynamicVideo)
|
||
{
|
||
if (File.Exists(mp3Path))
|
||
{
|
||
File.Delete(mp3Path);
|
||
}
|
||
//不保留原视频-删除
|
||
foreach (var opath in dynamicVideos)
|
||
{
|
||
if (File.Exists(opath.Path))
|
||
File.Delete(opath.Path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!remoteReady)
|
||
{
|
||
if (!string.IsNullOrWhiteSpace(dynamicVideo.VideoCoverSavePath))
|
||
await mediaStorageRouter.Resolve(dynamicVideo.StorageType).DeleteAsync(dynamicVideo.VideoCoverSavePath);
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-动态视频[{item.Desc}]合并或上传失败，不保存无效远端记录");
|
||
continue;
|
||
}
|
||
|
||
//动态视频生成nfo
|
||
if (dynamicVideo.StorageType == StorageType.Local && cate != null && (VideoType == VideoTypeEnum.dy_mix || VideoType == VideoTypeEnum.dy_series))
|
||
{
|
||
NfoFileGenerator.GenerateVideoNfoFile(config.CloseNfo,dynamicVideo, cate.Name);
|
||
}
|
||
else if (dynamicVideo.StorageType == StorageType.Local)
|
||
{
|
||
NfoFileGenerator.GenerateVideoNfoFile(config.CloseNfo, dynamicVideo);
|
||
}
|
||
await WriteRemoteNfoAsync(config, dynamicVideo, cate);
|
||
if (replaceOldStorage) dynamicVideo.SupersededStorageSnapshot = exitVideo;
|
||
videos.Add(dynamicVideo);
|
||
syncCount++;
|
||
if (syncCount + syncCount1 >= config.BatchCount)
|
||
{
|
||
return (videos, syncCount);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
CleanupTemporaryDirectory(dynamicVideo.TemporaryDirectory);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]-动态视频[{item.Desc}]，下载失败...");
|
||
if (!string.IsNullOrWhiteSpace(_currentTaskItemId))
|
||
await videoTaskService.MarkFailedAsync(_currentTaskItemId,
|
||
new MediaSourceException(MediaDownloadFailureKind.SourceUnavailable, "动态视频下载或合成失败"),
|
||
VideoTaskErrorType.SourceUnavailable);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var hasImages = item?.Images?.Any(image =>
|
||
image?.UrlList?.Any(url => !string.IsNullOrWhiteSpace(url)) == true ||
|
||
image?.DynamicVideo?.BitRate?.Any(rate =>
|
||
rate?.PlayAddr?.UrlList?.Any(url => !string.IsNullOrWhiteSpace(url)) == true) == true) == true;
|
||
if (!hasImages)
|
||
{
|
||
await videoTaskService.MarkSkippedAsync(_taskId, trackedAwemeId, cookie.Id, cookie.UserName,
|
||
VideoType, item?.Desc, item?.Author?.Nickname, VideoTaskSkipReason.NoMediaSource,
|
||
"作品没有可用的视频、图文或动态媒体源，已跳过并继续同步。");
|
||
}
|
||
// 处理图文视频逻辑
|
||
else if (config.DownImageVideo || config.DownMp3 || config.DownImage)
|
||
{
|
||
var mergevideo = await ProcessImageSetAndMergeToVideo(cookie, item, config, followed, cate);
|
||
if (mergevideo != null)
|
||
{
|
||
if (replaceOldStorage) mergevideo.SupersededStorageSnapshot = exitVideo;
|
||
videos.Add(mergevideo);
|
||
syncCount++;
|
||
if (syncCount + syncCount1 >= config.BatchCount)
|
||
{
|
||
return (videos, syncCount);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
await videoTaskService.MarkFailedAsync(_currentTaskItemId,
|
||
new IOException("图文媒体下载或合成失败，请重新执行对应的同步任务重试。"),
|
||
VideoTaskErrorType.SourceUnavailable);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
await videoTaskService.MarkSkippedAsync(_taskId, trackedAwemeId, cookie.Id, cookie.UserName,
|
||
VideoType, item?.Desc, item?.Author?.Nickname, VideoTaskSkipReason.ConfigurationExcluded,
|
||
"作品属于图文或动态内容，但当前配置未启用对应下载方式。");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
try
|
||
{
|
||
if (string.IsNullOrWhiteSpace(_currentTaskItemId))
|
||
{
|
||
var failedItem = await videoTaskService.AddItemAsync(_taskId, trackedAwemeId, cookie.Id,
|
||
cookie.UserName, VideoType, item?.Desc, item?.Author?.Nickname);
|
||
_currentTaskItemId = failedItem.Id;
|
||
}
|
||
await videoTaskService.MarkFailedAsync(_currentTaskItemId, ex);
|
||
}
|
||
catch (Exception trackingError)
|
||
{
|
||
Log.Error(trackingError, "[{Cookie}][{Type}]记录异常作品失败：{AwemeId}",
|
||
cookie.UserName, VideoType.GetDesc(), trackedAwemeId);
|
||
}
|
||
Log.Error(ex, "[{Cookie}][{Type}]作品处理失败，已跳过并继续：{AwemeId}",
|
||
cookie.UserName, VideoType.GetDesc(), trackedAwemeId);
|
||
}
|
||
}
|
||
return (videos, syncCount);
|
||
}
|
||
|
||
private async Task<bool> AutoDistinct(AppConfig config, DouyinVideo exitVideo, DouyinCookie cookie)
|
||
{
|
||
// 去重，检查视频是否已存在（按优先级下载）
|
||
if (config.AutoDistinct)
|
||
{
|
||
if (exitVideo != null)
|
||
{
|
||
// 2. 已存在视频：先判断本地文件是否存在
|
||
if (await mediaStorageRouter.Resolve(exitVideo.StorageType).ExistsAsync(exitVideo.VideoSavePath))
|
||
{
|
||
List<PriorityLevelDto> priLevs = new List<PriorityLevelDto>();
|
||
if (!string.IsNullOrWhiteSpace(config.PriorityLevel))
|
||
{
|
||
priLevs = JsonConvert.DeserializeObject<List<PriorityLevelDto>>(config.PriorityLevel);
|
||
}
|
||
|
||
// 4. 处理优先级：获取「最高优先级」（Sort 越小优先级越高）
|
||
PriorityLevelDto maxPriority = null;
|
||
if (priLevs.Any())
|
||
{
|
||
// 前端已配置优先级：取 Sort 最小的（1最高）
|
||
maxPriority = priLevs.OrderBy(x => x.Sort).FirstOrDefault();
|
||
}
|
||
else
|
||
{
|
||
// 前端未配置：使用默认优先级（喜欢 > 收藏 > 关注）
|
||
maxPriority = new PriorityLevelDto { Id = 1, Sort = 1, Name = "喜欢的" }; // 默认「喜欢的视频」最高
|
||
}
|
||
|
||
// 5. 转换为当前上下文的视频类型
|
||
var maxPriorityType = (VideoTypeEnum)maxPriority.Id; // 配置的最高优先级类型
|
||
|
||
// 6. 获取已存在视频的类型（从数据库中 exitVideo 读取，需确保字段存在）
|
||
var exitVideoType = exitVideo.ViedoType; // 假设数据库存储了 VideoType.GetVideoTypeDesc()（1/2/3）
|
||
|
||
// 7. 优先级逻辑判断（核心）
|
||
if (VideoType == maxPriorityType)
|
||
{
|
||
// 情况1：当前要下载的是「最高优先级」视频
|
||
if (exitVideoType == VideoType)
|
||
{
|
||
// 已存在同优先级视频 → 跳过下载（避免重复）
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频-{exitVideo.AwemeId}-[{exitVideo.VideoTitle}]已存在（同最高优先级），跳过");
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
// 已存在「低优先级」视频 → 替换（删除旧文件，继续下载新的最高优先级视频）
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频-{exitVideo.AwemeId}-[{exitVideo.VideoTitle}]已存在（低优先级：{exitVideoType.GetVideoTypeDesc()}），替换为最高优先级：{currentVideoType.GetVideoTypeDesc()}");
|
||
|
||
// 删除旧的低优先级文件（可选：也可保留备份，根据需求调整）
|
||
try
|
||
{
|
||
//File.Delete(exitVideo.VideoSavePath);
|
||
await DeleteOldVideoAsync(exitVideo);
|
||
//Log.Debug($"已删除旧文件：{exitVideo.VideoSavePath}");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-删除重复的文件[{exitVideo.VideoTitle}]失败：{ex.Message}", ex);
|
||
// 即使删除失败，仍继续下载（新文件会覆盖旧文件，或按路径规则重命名）
|
||
}
|
||
|
||
// 继续执行下载逻辑（覆盖旧数据）
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 情况2：当前要下载的是「非最高优先级」视频
|
||
if (exitVideoType == maxPriorityType)
|
||
{
|
||
// 已存在「最高优先级」视频 → 跳过（不替换最高优先级）
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频-{exitVideo.AwemeId}-[{exitVideo.VideoTitle}]已存在最高优先级视频（{maxPriorityType}），当前类型（{currentVideoType.GetVideoTypeDesc()}）优先级低，跳过");
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
// 已存在「其他非最高优先级」视频 → 比较两者优先级
|
||
// 获取当前类型和已存在类型的 Sort 值
|
||
var currentSort = priLevs.FirstOrDefault(x => x.Id == (int)VideoType)?.Sort ?? int.MaxValue;
|
||
var exitSort = priLevs.FirstOrDefault(x => x.Id == (int)exitVideoType)?.Sort ?? int.MaxValue;
|
||
|
||
if (currentSort < exitSort)
|
||
{
|
||
// 当前类型优先级更高 → 替换旧视频
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频-{exitVideo.AwemeId}-[{exitVideo.VideoTitle}]已存在低优先级视频（{exitVideoType.GetVideoTypeDesc()}），替换为当前优先级：{currentVideoType.GetVideoTypeDesc()}");
|
||
// 删除旧文件
|
||
await DeleteOldVideoAsync(exitVideo);
|
||
// 继续下载
|
||
}
|
||
else
|
||
{
|
||
// 当前类型优先级更低或相等 → 跳过
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频-{exitVideo.AwemeId}-[{exitVideo.VideoTitle}]已存在更高/同等优先级视频（{exitVideoType.GetVideoTypeDesc()}），当前类型（{currentVideoType.GetVideoTypeDesc()}）跳过");
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (exitVideo.OnlyImgOrOnlyMp3)
|
||
{
|
||
return true;//说明是图文视频，不需要再下载视频了
|
||
}
|
||
else
|
||
{
|
||
//记录存在，但本地文件不存在，则继续下载。
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频-{exitVideo.AwemeId}记录存在，但本地文件缺失，删除记录，重新下载");
|
||
//删除原来的记录
|
||
await douyinVideoService.DeleteById(exitVideo.Id);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private async Task DeleteOldVideoAsync(DouyinVideo exitVideo)
|
||
{
|
||
if (exitVideo.StorageType.IsRemote())
|
||
{
|
||
await StorageArtifactCleaner.DeleteWebDavArtifactsAsync(
|
||
mediaStorageRouter.Resolve(exitVideo.StorageType), exitVideo);
|
||
return;
|
||
}
|
||
if (File.Exists(exitVideo.VideoSavePath))
|
||
{
|
||
var dirPath = Path.GetDirectoryName(exitVideo.VideoSavePath);
|
||
if (Directory.Exists(dirPath))
|
||
{
|
||
Directory.Delete(dirPath, true);
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-已删除旧文件夹：{dirPath}");
|
||
}
|
||
//查看是否还有其他文件，如果没有则删除文件夹
|
||
var parentDir = Path.GetDirectoryName(exitVideo.VideoSavePath);
|
||
if (Directory.Exists(parentDir) && !Directory.EnumerateFileSystemEntries(parentDir).Any())
|
||
{
|
||
Directory.Delete(parentDir);
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-已删除空文件夹：{parentDir}");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 处理单个视频--正常的收藏喜欢关注的 视频
|
||
/// 负责下载视频、封面、头像，生成NFO文件，创建视频实体等
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="item">视频信息</param>
|
||
/// <param name="config">应用配置</param>
|
||
/// <param name="followed">关注</param>
|
||
/// <param name="cate"></param>
|
||
/// <returns>处理后的视频实体，如果处理失败则为null</returns>
|
||
protected async Task<DouyinVideo> ProcessSingleVideo(
|
||
DouyinCookie cookie,
|
||
Aweme item,
|
||
AppConfig config,
|
||
DouyinFollowed followed = null,
|
||
DouyinCollectCate cate = null,
|
||
DouyinVideo supersededStorageSnapshot = null)
|
||
{
|
||
// 检查视频数据是否有效
|
||
if (!IsAwemeValid(item)) return null;
|
||
// 获取视频最佳下载地址
|
||
var v = GetBestMatchedVideoUrl(item, config);
|
||
|
||
if (v == null)
|
||
{
|
||
Serilog.Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}][{item.Desc}]未获取到下载地址");
|
||
return null;
|
||
}
|
||
//Serilog.Log.Debug($"{v.QualityType}-{v.BitRateValue}-{v.IsH265}-{v.HdrBit}");
|
||
var candidates = GetMediaCandidates(item, v);
|
||
var videoUrl = candidates.FirstOrDefault();
|
||
if (string.IsNullOrWhiteSpace(videoUrl))
|
||
{
|
||
Serilog.Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]未获取到下载地址");
|
||
return null;
|
||
}
|
||
// 创建保存文件夹
|
||
var saveFolder = CreateSaveFolder(cookie, item, config, followed, cate);
|
||
// 获取视频文件名
|
||
var fileName = GetVideoFileName(cookie, item, config, cate);
|
||
// 拼接视频保存路径
|
||
var savePath = CombineStoragePath(saveFolder, fileName);
|
||
|
||
var retrySnapshot = BuildRetrySnapshot(cookie, item, v, savePath, cate, supersededStorageSnapshot);
|
||
await videoTaskService.UpdateItemPlanAsync(_currentTaskItemId, savePath, retrySnapshot, v.PlayAddr?.DataSize ?? 0);
|
||
|
||
// 如果文件已存在，跳过
|
||
if (await mediaStorageRouter.Resolve(ActiveStorageType).ExistsAsync(savePath))
|
||
{
|
||
if (supersededStorageSnapshot != null)
|
||
{
|
||
var length = await mediaStorageRouter.Resolve(ActiveStorageType).GetLengthAsync(savePath) ?? 0;
|
||
if (length <= 0)
|
||
throw new IOException($"{ActiveStorageType} 目标文件存在但长度无效：{savePath}");
|
||
var adopted = JsonConvert.DeserializeObject<DouyinVideo>(
|
||
JsonConvert.SerializeObject(supersededStorageSnapshot));
|
||
adopted.StorageType = ActiveStorageType;
|
||
adopted.VideoSavePath = savePath;
|
||
adopted.FileSize = length;
|
||
adopted.SyncTime = DateTime.Now;
|
||
adopted.TaskItemId = _currentTaskItemId;
|
||
adopted.SupersededStorageSnapshot = supersededStorageSnapshot.StorageType == StorageType.Local
|
||
? supersededStorageSnapshot : null;
|
||
await videoTaskService.UpdateItemPlanAsync(_currentTaskItemId, savePath, adopted, length);
|
||
await videoTaskService.SetItemStageAsync(_currentTaskItemId, VideoTaskItemStage.Committing, savePath);
|
||
return adopted;
|
||
}
|
||
await videoTaskService.MarkSkippedAsync(_taskId, item.AwemeId, cookie.Id, cookie.UserName, VideoType,
|
||
item.Desc, item.Author?.Nickname, VideoTaskSkipReason.AlreadyExists, "目标文件已存在。");
|
||
_currentTaskItemId = null;
|
||
return null;
|
||
}
|
||
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}][{item?.Author?.Nickname ?? ""}]-视频[{DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId)}]开始下载...");
|
||
// 随机延迟
|
||
await Task.Delay(_random.Next(1, 4) * 1000);
|
||
|
||
// 下载视频
|
||
await videoTaskService.SetItemStageAsync(_currentTaskItemId, VideoTaskItemStage.Downloading, savePath);
|
||
var download = await douyinHttpClientService.DownloadToStorageAsync(
|
||
ActiveStorageType,
|
||
videoUrl,
|
||
savePath,
|
||
cookie.Cookies,
|
||
candidates.Skip(1).ToList(),
|
||
maxRetryCount: Math.Min(12, candidates.Count));
|
||
if (!download.Success)
|
||
{
|
||
var disposition = await videoTaskService.MarkDownloadFailedAsync(_currentTaskItemId, cookie.Id, download);
|
||
_stopCurrentCookie = disposition is SourceFailureDisposition.WaitForSource or SourceFailureDisposition.RequiresAuthorization;
|
||
Log.Warning("[{Cookie}][{Type}]媒体下载失败：Host={Host}, Status={Status}, Kind={Kind}, Candidates={Candidates}",
|
||
cookie.UserName, VideoType.GetDesc(), download.SourceHost, download.HttpStatusCode,
|
||
download.FailureKind, download.AttemptedUrlCount);
|
||
_currentTaskItemId = null;
|
||
return null;
|
||
}
|
||
savePath = download.ActualSavePath;
|
||
await videoTaskService.RecordSourceSuccessAsync(cookie.Id);
|
||
if (ActiveStorageType == StorageType.Local)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}][{item?.Author?.Nickname ?? ""}]-视频[{DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId)}]下载完成.");
|
||
}
|
||
await videoTaskService.SetItemStageAsync(_currentTaskItemId, VideoTaskItemStage.Verifying, savePath);
|
||
var actualLength = await mediaStorageRouter.Resolve(ActiveStorageType).GetLengthAsync(savePath);
|
||
if (!actualLength.HasValue || actualLength <= 0)
|
||
{
|
||
var error = new IOException("下载完成后没有找到有效的主媒体文件");
|
||
await videoTaskService.MarkFailedAsync(_currentTaskItemId, error, VideoTaskErrorType.IntegrityCheckFailed);
|
||
return null;
|
||
}
|
||
// 下载视频封面
|
||
var coverSavePath = await DownVideoCover(item, savePath, cookie, cate,config);
|
||
// 下载作者头像
|
||
var avatarSavePath = await DownAuthorAvatar(cookie, item,config);
|
||
|
||
// 创建视频实体
|
||
var entity = await CreateVideoEntity(config, cookie, item, v, savePath, coverSavePath, avatarSavePath, null, cate);
|
||
if (supersededStorageSnapshot != null)
|
||
{
|
||
entity.Id = supersededStorageSnapshot.Id;
|
||
entity.SupersededStorageSnapshot = supersededStorageSnapshot;
|
||
}
|
||
entity.FileSize = actualLength.Value;
|
||
entity.TaskItemId = _currentTaskItemId;
|
||
await videoTaskService.UpdateItemPlanAsync(_currentTaskItemId, savePath, entity, actualLength.Value);
|
||
await videoTaskService.SetItemStageAsync(_currentTaskItemId, VideoTaskItemStage.Committing, savePath);
|
||
return entity;
|
||
}
|
||
|
||
private DouyinVideo BuildRetrySnapshot(
|
||
DouyinCookie cookie,
|
||
Aweme item,
|
||
VideoBitRate bitRate,
|
||
string savePath,
|
||
DouyinCollectCate cate,
|
||
DouyinVideo supersededStorageSnapshot)
|
||
{
|
||
return new DouyinVideo
|
||
{
|
||
Id = supersededStorageSnapshot?.Id ?? IdGener.GetLong().ToString(),
|
||
ViedoType = VideoType,
|
||
StorageType = ActiveStorageType,
|
||
AwemeId = item.AwemeId,
|
||
CookieId = cookie.Id,
|
||
Author = item.Author?.Nickname,
|
||
AuthorId = item.Author?.Uid,
|
||
DyUserId = item.AuthorUserId == 0 ? item.Author?.Uid : item.AuthorUserId.ToString(),
|
||
VideoTitle = string.IsNullOrWhiteSpace(item.Desc) ? $"{item.Author?.Nickname}-{item.CreateTime}" : item.Desc,
|
||
VideoUrl = bitRate.PlayAddr?.UrlList?.FirstOrDefault(),
|
||
VideoSavePath = savePath,
|
||
FileSize = bitRate.PlayAddr?.DataSize ?? 0,
|
||
FileHash = bitRate.PlayAddr?.FileHash,
|
||
Resolution = $"{bitRate.PlayAddr?.Width}×{bitRate.PlayAddr?.Height}",
|
||
CreateTime = DateTimeUtil.Convert10BitTimestamp(item.CreateTime),
|
||
SyncTime = DateTime.Now,
|
||
CateId = cate?.Id,
|
||
CateXId = cate?.XId,
|
||
SupersededStorageSnapshot = supersededStorageSnapshot
|
||
};
|
||
}
|
||
|
||
internal static VideoBitRate GetBestMatchedVideoUrl(Aweme item, AppConfig config)
|
||
{
|
||
var bitRates = item?.Video?.BitRate?
|
||
.Where(rate => rate?.PlayAddr?.UrlList?.Any(url => !string.IsNullOrWhiteSpace(url)) == true)
|
||
.ToList() ?? new List<VideoBitRate>();
|
||
if (bitRates.Count == 0) return null;
|
||
|
||
VideoBitRate v;
|
||
if (config?.VideoEncoder.HasValue == true && config.VideoEncoder.Value == 265)
|
||
{
|
||
v = bitRates.Where(v => v.IsH265 == 1)
|
||
.OrderByDescending(v => v.BitRateValue)
|
||
.FirstOrDefault();
|
||
v ??= bitRates.Where(v => v.IsH265 == 0)
|
||
.OrderByDescending(v => v.BitRateValue)
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
else
|
||
{
|
||
v = bitRates.Where(v => v.IsH265 == 0)
|
||
.OrderByDescending(v => v.BitRateValue)
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
return v;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 动态视频处理
|
||
/// </summary>
|
||
/// <param name="dynamicUrls"></param>
|
||
/// <param name="cookie"></param>
|
||
/// <param name="item"></param>
|
||
/// <param name="config"></param>
|
||
/// <param name="followed"></param>
|
||
/// <param name="cate"></param>
|
||
/// <returns></returns>
|
||
protected async Task<DouyinVideo> ProcessDynamicVideo(List<DouyinMergeVideoDto> dynamicUrls, DouyinCookie cookie, Aweme item, AppConfig config, DouyinFollowed followed = null, DouyinCollectCate cate = null)
|
||
{
|
||
string temporaryDirectory = null;
|
||
var handedOffForMerge = false;
|
||
try
|
||
{
|
||
// 创建保存文件夹
|
||
var targetFolder = CreateSaveFolder(cookie, item, config, followed, cate);
|
||
// 获取视频文件名
|
||
//var fileName = DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId) + ".mp4";
|
||
|
||
var fileName = GetVideoFileName(cookie, item, config, cate);
|
||
// 拼接视频保存路径
|
||
var targetSavePath = CombineStoragePath(targetFolder, fileName);
|
||
temporaryDirectory = ActiveStorageType.IsRemote() ? CreateTemporaryDirectory() : null;
|
||
var saveFolder = temporaryDirectory ?? targetFolder;
|
||
var savePath = Path.Combine(saveFolder, fileName);
|
||
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]-动态视频[{DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId)}]开始下载...");
|
||
// 随机延迟
|
||
int i = 1;
|
||
|
||
List<DouyinMergeVideoDto> dynamicSavePaths = new List<DouyinMergeVideoDto>();
|
||
MediaDownloadResult lastDownloadFailure = null;
|
||
var allSourceForbidden = true;
|
||
var failedParts = 0;
|
||
foreach (var dynamicUrl in dynamicUrls)
|
||
{
|
||
// 下载动态视频
|
||
var dynamicSavePath = savePath.Replace(".mp4", $"_00{i}.mp4");
|
||
DouyinMergeVideoDto v = new DouyinMergeVideoDto() { Height = dynamicUrl.Height, Width = dynamicUrl.Width, Path = dynamicSavePath };
|
||
|
||
i++;
|
||
// 如果文件已存在，跳过
|
||
if (File.Exists(dynamicSavePath))
|
||
{
|
||
//Log.Debug($"[{VideoType.GetVideoTypeDesc()}]-视频[{DouyinFileNameHelper.SanitizePath(item.Desc)}]已存在，跳过下载.");
|
||
dynamicSavePaths.Add(v);
|
||
continue;
|
||
}
|
||
var download = await douyinHttpClientService.DownloadAsync(dynamicUrl.Path, dynamicSavePath, cookie.Cookies);
|
||
if (!download.Success)
|
||
{
|
||
failedParts++;
|
||
lastDownloadFailure = download;
|
||
allSourceForbidden &= download.FailureKind == MediaDownloadFailureKind.SourceForbidden;
|
||
Log.Warning("[{Cookie}][{Type}]动态视频分片下载失败：Host={Host}, Status={Status}, Kind={Kind}",
|
||
cookie.UserName, VideoType.GetDesc(), download.SourceHost, download.HttpStatusCode, download.FailureKind);
|
||
}
|
||
else
|
||
{
|
||
v.Path = download.ActualSavePath;
|
||
dynamicSavePaths.Add(v);
|
||
await videoTaskService.RecordSourceSuccessAsync(cookie.Id);
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}][{item?.Author?.Nickname ?? ""}]-动态视频[{dynamicSavePath}]-00{i},下载完成.");
|
||
}
|
||
await Task.Delay(_random.Next(2, 10) * 1000);
|
||
}
|
||
|
||
if (dynamicSavePaths.Count == 0)
|
||
{
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-动态视频[{item.Desc}]没有下载到可用分片");
|
||
if (lastDownloadFailure != null && !string.IsNullOrWhiteSpace(_currentTaskItemId))
|
||
{
|
||
if (!allSourceForbidden && lastDownloadFailure.FailureKind == MediaDownloadFailureKind.SourceForbidden)
|
||
lastDownloadFailure = new MediaDownloadResult
|
||
{
|
||
Success = false,
|
||
ActualSavePath = lastDownloadFailure.ActualSavePath,
|
||
FailureKind = MediaDownloadFailureKind.SourceUnavailable,
|
||
SourceHost = lastDownloadFailure.SourceHost,
|
||
AttemptedUrlCount = failedParts,
|
||
Message = "动态视频分片返回了多种来源错误。"
|
||
};
|
||
var disposition = await videoTaskService.MarkDownloadFailedAsync(_currentTaskItemId, cookie.Id, lastDownloadFailure);
|
||
_stopCurrentCookie = disposition is SourceFailureDisposition.WaitForSource or SourceFailureDisposition.RequiresAuthorization;
|
||
_currentTaskItemId = null;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// 下载视频封面
|
||
var coverSavePath = await DownVideoCover(item, ActiveStorageType.IsRemote() ? targetSavePath : savePath, cookie, cate,config);
|
||
// 下载作者头像
|
||
var avatarSavePath = await DownAuthorAvatar(cookie, item, config);
|
||
|
||
// 创建视频实体
|
||
var virtualBitRate = new VideoBitRate
|
||
{
|
||
PlayAddr = new PlayAddr
|
||
{
|
||
Width = item?.Images?.FirstOrDefault()?.Width ?? 0,
|
||
Height = item?.Images?.FirstOrDefault()?.Height ?? 0,
|
||
DataSize = DouyinFileUtils.GetTotalFileSize(dynamicSavePaths.Select(x => x.Path).ToList()) // 合成视频的文件大小
|
||
}
|
||
};
|
||
var entity = await CreateVideoEntity(config, cookie, item, virtualBitRate, dynamicSavePaths.FirstOrDefault()?.Path, coverSavePath, avatarSavePath, dynamicSavePaths, cate);
|
||
entity.PendingStoragePath = targetSavePath;
|
||
entity.TemporaryDirectory = temporaryDirectory;
|
||
handedOffForMerge = true;
|
||
return entity;
|
||
}
|
||
finally
|
||
{
|
||
if (!handedOffForMerge) CleanupTemporaryDirectory(temporaryDirectory);
|
||
}
|
||
}
|
||
|
||
|
||
internal static List<string> GetMediaCandidates(Aweme item, VideoBitRate selected)
|
||
{
|
||
var result = new List<string>();
|
||
void Add(VideoBitRate bitRate)
|
||
{
|
||
foreach (var url in bitRate?.PlayAddr?.UrlList ?? new List<string>())
|
||
if (!string.IsNullOrWhiteSpace(url) && !result.Contains(url, StringComparer.Ordinal)) result.Add(url);
|
||
}
|
||
Add(selected);
|
||
foreach (var bitRate in item?.Video?.BitRate ?? new List<VideoBitRate>()) Add(bitRate);
|
||
return result.Take(12).ToList();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 负责下载图片、合成视频、处理封面和头像等
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="item">视频信息（包含图片集）</param>
|
||
/// <param name="config">应用配置</param>
|
||
/// <param name="followed">应用配置</param>
|
||
/// <param name="cate"></param>
|
||
/// <returns>合成后的视频实体，如果处理失败则为null</returns>
|
||
protected async Task<DouyinVideo> ProcessImageSetAndMergeToVideo(DouyinCookie cookie, Aweme item, AppConfig config, DouyinFollowed followed, DouyinCollectCate cate)
|
||
{
|
||
string temporaryDirectory = null;
|
||
try
|
||
{
|
||
// 提取图片URL列表
|
||
List<DouyinMergeVideoDto> imageUrls = item?.Images?
|
||
.Where(img => img?.UrlList != null && img.UrlList.Any())
|
||
.Select(img => new DouyinMergeVideoDto { Path = img.UrlList.FirstOrDefault(), Height = img.Height, Width = img.Width })
|
||
.Where(img => !string.IsNullOrWhiteSpace(img.Path))
|
||
.ToList();
|
||
|
||
// 如果没有图片，保留明确失败原因供任务中心展示。
|
||
if (imageUrls == null || !imageUrls.Any())
|
||
{
|
||
throw new InvalidOperationException("图文作品没有可用的静态图片地址");
|
||
}
|
||
|
||
// 创建图片保存文件夹
|
||
var targetFolder = CreateSaveFolder(cookie, item, config, followed, cate);
|
||
temporaryDirectory = ActiveStorageType.IsRemote() ? CreateTemporaryDirectory() : null;
|
||
var fileNamefolder = temporaryDirectory ?? targetFolder;
|
||
if (!Directory.Exists(fileNamefolder)) Directory.CreateDirectory(fileNamefolder);
|
||
|
||
var fileName = GetVideoFileName(cookie, item, config, cate);
|
||
// 合成视频的保存路径
|
||
var savePath = Path.Combine(fileNamefolder, fileName);
|
||
var targetSavePath = CombineStoragePath(targetFolder, fileName);
|
||
|
||
// 如果文件已存在，返回null
|
||
if (File.Exists(savePath))
|
||
{
|
||
FileInfo fileInfo = new FileInfo(savePath);
|
||
if (fileInfo.Length > 0)
|
||
return null;
|
||
}
|
||
|
||
// 获取音乐URL
|
||
var mp3Url = item.Music?.PlayUrl?.UrlList?.FirstOrDefault();
|
||
var firstImage = item.Images.FirstOrDefault(img => img != null);
|
||
int height = firstImage?.Height ?? 0;
|
||
int width = firstImage?.Width ?? 0;
|
||
|
||
// 准备合成视频的请求参数
|
||
var reqParams = new MediaMergeRequest
|
||
{
|
||
ImageDurationPerSecond = 3, // 每张图片显示的时长（秒）
|
||
OutputFormat = "mp4", // 输出视频格式
|
||
VideoFps = 30, // 视频帧率
|
||
AudioUrls = string.IsNullOrWhiteSpace(mp3Url) ? new List<string>() : new List<string> { mp3Url }, // 音频URL列表
|
||
ImageUrls = imageUrls, // 图片URL列表
|
||
VideoWidth = width > 0 ? width : 1080, // 视频宽度
|
||
VideoHeight = height > 0 ? height : 1920, // 视频高度
|
||
};
|
||
|
||
|
||
// 执行图片合成视频操作
|
||
string mergeError = null;
|
||
var mergeResult = await douyinMergeVideoService.MergeToVideo(
|
||
cookie.Cookies,
|
||
AppContext.BaseDirectory,
|
||
reqParams,
|
||
savePath,
|
||
fileNamefolder,
|
||
config.DownImageVideo,
|
||
config.DownImage,
|
||
config.DownMp3,
|
||
warning => _currentItemWarnings.Add(warning),
|
||
error => mergeError = error);
|
||
if (!mergeResult)
|
||
{
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-图文视频-[{DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId)}]合成失败!!!");
|
||
throw new InvalidOperationException(
|
||
$"图文媒体下载或合成失败：{mergeError ?? "未生成有效媒体文件"}");
|
||
}
|
||
|
||
// 获取不带扩展名的完整路径
|
||
//string fullPathWithoutExtension = Path.Combine(Path.GetDirectoryName(savePath),Path.GetFileNameWithoutExtension(savePath) );
|
||
if (config.DownImageVideo)
|
||
{
|
||
// 检查合成后的视频文件是否有效
|
||
if (!File.Exists(savePath) || new FileInfo(savePath).Length <= 0)
|
||
{
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-图文视频-[{DouyinFileNameHelper.SanitizeLinuxFileName(item.Desc, item.AwemeId)}]合成失败!!!");
|
||
// 清理无效的文件和文件夹
|
||
if (Directory.Exists(fileNamefolder))
|
||
{
|
||
File.Delete(savePath);
|
||
Directory.Delete(fileNamefolder, true);
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-图文视频-删除合成失败的视频文件和目录...");
|
||
}
|
||
throw new MediaIntegrityException("图文合成完成，但输出视频不存在或为空");
|
||
}
|
||
}
|
||
var isMediaOnly = !config.DownImageVideo && (config.DownImage || config.DownMp3);
|
||
var localArtifactPath = config.DownImageVideo
|
||
? savePath
|
||
: Directory.EnumerateFiles(fileNamefolder, "*", SearchOption.AllDirectories).FirstOrDefault();
|
||
if (string.IsNullOrWhiteSpace(localArtifactPath) || !File.Exists(localArtifactPath))
|
||
{
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-图文作品[{item.Desc}]未生成任何可保存的媒体文件");
|
||
throw new InvalidOperationException("图文处理完成，但未生成任何可保存的媒体文件");
|
||
}
|
||
|
||
var generatedSize = new FileInfo(localArtifactPath).Length;
|
||
var storageArtifactPath = localArtifactPath;
|
||
List<DouyinMergeVideoDto> uploadedArtifacts = null;
|
||
|
||
if (ActiveStorageType.IsRemote())
|
||
{
|
||
var uploadedPaths = await UploadDirectoryAsync(fileNamefolder, targetFolder);
|
||
uploadedArtifacts = Directory.EnumerateFiles(fileNamefolder, "*", SearchOption.AllDirectories)
|
||
.Select(file => new DouyinMergeVideoDto
|
||
{
|
||
Path = uploadedPaths[Path.GetRelativePath(fileNamefolder, file).Replace('\\', '/')]
|
||
})
|
||
.ToList();
|
||
var relativeArtifact = Path.GetRelativePath(fileNamefolder, localArtifactPath).Replace('\\', '/');
|
||
storageArtifactPath = config.DownImageVideo
|
||
? uploadedPaths.GetValueOrDefault(
|
||
Path.GetRelativePath(fileNamefolder, savePath).Replace('\\', '/'), targetSavePath)
|
||
: uploadedPaths.GetValueOrDefault(
|
||
relativeArtifact, StoragePath.CombineRemote(targetFolder, relativeArtifact));
|
||
}
|
||
|
||
var coverUrl = cate is not null && cate.CateType != VideoTypeEnum.dy_custom_collect
|
||
? (item.MixInfo?.CoverUrl?.UrlList?.FirstOrDefault() ?? imageUrls.FirstOrDefault()?.Path ?? item.Music?.CoverHd?.UrlList?.FirstOrDefault())
|
||
: imageUrls.FirstOrDefault()?.Path;
|
||
|
||
// 下载作者头像
|
||
var avatarSavePath = await DownAuthorAvatar(cookie, item, config);
|
||
|
||
// 为合成的视频创建一个“虚拟”的BitRate对象，以便复用CreateVideoEntity方法
|
||
var virtualBitRate = new VideoBitRate
|
||
{
|
||
PlayAddr = new PlayAddr
|
||
{
|
||
Width = reqParams.VideoWidth,
|
||
Height = reqParams.VideoHeight,
|
||
DataSize = generatedSize
|
||
}
|
||
};
|
||
// 下载视频封面（使用第一张图片作为封面）
|
||
var coverReferencePath = storageArtifactPath;
|
||
string coverSavePath = await DownVideoCover(coverUrl, coverReferencePath, cookie, config);
|
||
|
||
// 创建视频实体
|
||
var videoEntity = await CreateVideoEntity(config,
|
||
cookie, item, virtualBitRate, storageArtifactPath, coverSavePath, avatarSavePath, null, cate, isMediaOnly);
|
||
|
||
// 特殊处理合成视频的字段
|
||
videoEntity.FileHash = string.Empty; // 合成视频没有原始文件哈希
|
||
videoEntity.VideoUrl = "/"; // 合成视频没有原始URL
|
||
videoEntity.ViedoType = VideoType;
|
||
videoEntity.IsMergeVideo = 1;// 标记为图片合成视频
|
||
if (uploadedArtifacts?.Count > 0)
|
||
videoEntity.DynamicVideos = JsonConvert.SerializeObject(uploadedArtifacts);
|
||
|
||
|
||
return videoEntity;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, $"[{cookie.UserName}][{VideoType.GetDesc()}]-图片视频同步-处理图片集并合成视频时出错");
|
||
if (ActiveStorageType.IsRemote() && ex is IOException
|
||
&& ex is not (MediaStorageException or MediaIntegrityException))
|
||
throw new MediaStorageException($"图文媒体写入 {ActiveStorageType} 失败", ex);
|
||
throw;
|
||
}
|
||
finally
|
||
{
|
||
CleanupTemporaryDirectory(temporaryDirectory);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 保存视频信息到数据库
|
||
/// 批量插入视频实体列表到数据库中
|
||
/// </summary>
|
||
/// <param name="cookie"></param>
|
||
/// <param name="videos">要保存的视频实体列表</param>
|
||
/// <returns>保存成功的视频数量</returns>
|
||
protected async Task<int> SaveVideos(DouyinCookie cookie, List<DouyinVideo> videos)
|
||
{
|
||
if (!videos.Any()) return 0;
|
||
try
|
||
{
|
||
var saved = await douyinVideoService.BatchInsertOrUpdate(videos);
|
||
if (!saved)
|
||
{
|
||
Log.Error($"[{cookie.UserName}][{VideoType.GetDesc()}]-批量保存视频到数据库失败，开始清理已写入媒体");
|
||
foreach (var video in videos.Where(x => !string.IsNullOrWhiteSpace(x.TaskItemId)))
|
||
await videoTaskService.MarkFailedAsync(video.TaskItemId,
|
||
new IOException("数据库提交失败"), VideoTaskErrorType.DatabaseCommitFailed);
|
||
await CleanupFailedVideos(cookie, videos);
|
||
return 0;
|
||
}
|
||
foreach (var video in videos.Where(x => !string.IsNullOrWhiteSpace(x.TaskItemId)))
|
||
{
|
||
var length = await mediaStorageRouter.Resolve(video.StorageType).GetLengthAsync(video.VideoSavePath) ?? video.FileSize;
|
||
var warning = video.TaskWarning;
|
||
var cleanupPending = false;
|
||
string cleanupError = null;
|
||
if (video.SupersededStorageSnapshot != null)
|
||
{
|
||
try
|
||
{
|
||
await douyinVideoService.CleanupSupersededLocalArtifactsAsync(
|
||
video.SupersededStorageSnapshot, video.VideoSavePath);
|
||
}
|
||
catch (Exception cleanupException)
|
||
{
|
||
Log.Warning(cleanupException, "新存储记录已提交，但旧本地文件清理失败：{AwemeId}", video.AwemeId);
|
||
cleanupPending = true;
|
||
cleanupError = cleanupException.GetBaseException().Message;
|
||
warning = string.IsNullOrWhiteSpace(warning)
|
||
? $"已切换到 {video.StorageType}，但旧本地文件清理失败，可稍后重试清理。"
|
||
: warning + $"；已切换到 {video.StorageType}，但旧本地文件清理失败，可稍后重试清理。";
|
||
}
|
||
}
|
||
await videoTaskService.MarkSucceededAsync(video.TaskItemId, length, video.Id, warning,
|
||
cleanupPending, cleanupError);
|
||
}
|
||
return videos.Count;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Error(ex, $"[{cookie.UserName}][{VideoType.GetDesc()}]-批量保存视频到数据库失败");
|
||
foreach (var video in videos.Where(x => !string.IsNullOrWhiteSpace(x.TaskItemId)))
|
||
await videoTaskService.MarkFailedAsync(video.TaskItemId, ex, VideoTaskErrorType.DatabaseCommitFailed);
|
||
// 清理保存失败的视频文件
|
||
await CleanupFailedVideos(cookie, videos);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 下载视频封面
|
||
/// 从视频信息中提取封面URL并下载到指定文件夹
|
||
/// </summary>
|
||
/// <param name="item">视频信息</param>
|
||
/// <param name="savePath">视频保存路径</param>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="cate"></param>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
protected async Task<string> DownVideoCover(Aweme item, string savePath, DouyinCookie cookie, DouyinCollectCate cate,AppConfig config)
|
||
{
|
||
if (config.CloseNfo) return string.Empty;
|
||
// 定义封面URL变量
|
||
string coverUrl;
|
||
|
||
// 按照优先级获取封面URL
|
||
if (cate is not null)
|
||
{
|
||
// cate不为空时：优先MixInfo封面 → 其次Music高清封面 → 最后Video封面
|
||
coverUrl = item.MixInfo?.CoverUrl?.UrlList?.FirstOrDefault()
|
||
?? item.Video?.Cover?.UrlList?.LastOrDefault()
|
||
?? item.Music?.CoverHd?.UrlList?.FirstOrDefault();
|
||
}
|
||
else
|
||
{
|
||
// cate为空时：只取Video封面
|
||
coverUrl = item.Video?.Cover?.UrlList?.FirstOrDefault();
|
||
if (string.IsNullOrWhiteSpace(coverUrl))
|
||
{
|
||
coverUrl = item.Images?.FirstOrDefault()?.DynamicVideo?.Cover?.UrlList?.FirstOrDefault();
|
||
}
|
||
}
|
||
// 调用下载封面的方法
|
||
return await DownVideoCover(coverUrl, savePath, cookie, config);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 下载作者头像
|
||
/// 从视频信息中提取作者头像URL并下载到指定文件夹
|
||
/// </summary>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="item">视频信息</param>
|
||
/// <returns>一个元组，包含头像保存路径和头像URL</returns>
|
||
protected async Task<string> DownAuthorAvatar(DouyinCookie cookie, Aweme item,AppConfig config)
|
||
{
|
||
if (config.CloseNfo) return string.Empty;
|
||
if (item.Author == null) return string.Empty;
|
||
// 优先获取高清头像
|
||
var avatarUrl = item.Author.AvatarLarger?.UrlList?.FirstOrDefault() ?? item.Author.AvatarThumb?.UrlList?.FirstOrDefault();
|
||
if (string.IsNullOrWhiteSpace(avatarUrl)) return string.Empty;
|
||
|
||
// 拼接头像保存路径
|
||
var avatarSavePath = CombineStoragePath(GetAuthorAvatarBasePath(cookie), $"{item.Author.Uid}.jpg");
|
||
var avatarDir = ActiveStorageType.IsRemote() ? StoragePath.DirectoryName(avatarSavePath) : Path.GetDirectoryName(avatarSavePath);
|
||
EnsureStorageDirectory(avatarDir);
|
||
// 如果头像文件不存在，则下载
|
||
if (!await mediaStorageRouter.Resolve(ActiveStorageType).ExistsAsync(avatarSavePath))
|
||
{
|
||
var result = await douyinHttpClientService.DownloadToStorageAsync(ActiveStorageType, avatarUrl, avatarSavePath, cookie.Cookies);
|
||
if (!result.Success)
|
||
{
|
||
_currentItemWarnings.Add($"头像下载失败（{result.SourceHost ?? "未知来源"}/{result.HttpStatusCode?.ToString() ?? result.FailureKind.ToString()}）");
|
||
return string.Empty;
|
||
}
|
||
avatarSavePath = result.ActualSavePath;
|
||
}
|
||
return avatarSavePath;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 私有方法
|
||
|
||
/// <summary>
|
||
/// 检查视频数据是否有效
|
||
/// 验证视频信息是否包含必要的字段
|
||
/// </summary>
|
||
/// <param name="item">视频信息</param>
|
||
/// <returns>如果视频数据有效，则为true；否则为false</returns>
|
||
private static bool IsAwemeValid(Aweme item) => item != null && item.Video != null && item.Video.BitRate != null;
|
||
|
||
/// <summary>
|
||
/// 获取视频标签
|
||
/// 从视频信息中提取三个级别的标签
|
||
/// </summary>
|
||
/// <param name="item">视频信息</param>
|
||
/// <returns>一个元组，包含三个级别的视频标签</returns>
|
||
protected (string tag1, string tag2, string tag3) GetVideoTags(Aweme item)
|
||
{
|
||
var tags = item.VideoTags;
|
||
return (
|
||
tags?.FirstOrDefault(x => x.Level == 1)?.TagName,
|
||
tags?.FirstOrDefault(x => x.Level == 2)?.TagName,
|
||
tags?.FirstOrDefault(x => x.Level == 3)?.TagName
|
||
);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 清理保存失败的视频文件
|
||
/// 当数据库保存失败时，删除已下载的视频文件和文件夹
|
||
/// </summary>
|
||
/// <param name="cookie"></param>
|
||
/// <param name="videos">保存失败的视频实体列表</param>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
private async Task CleanupFailedVideos(DouyinCookie cookie, List<DouyinVideo> videos)
|
||
{
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]-数据库保存失败，开始清理本次下载的视频目录...");
|
||
|
||
foreach (var video in videos)
|
||
{
|
||
try
|
||
{
|
||
var storage = mediaStorageRouter.Resolve(video.StorageType);
|
||
if (video.StorageType.IsRemote())
|
||
{
|
||
await StorageArtifactCleaner.DeleteWebDavArtifactsAsync(storage, video);
|
||
}
|
||
else
|
||
{
|
||
if (!string.IsNullOrWhiteSpace(video.VideoSavePath))
|
||
await storage.DeleteAsync(video.VideoSavePath);
|
||
if (!string.IsNullOrWhiteSpace(video.VideoCoverSavePath) && video.VideoCoverSavePath != video.VideoSavePath)
|
||
await storage.DeleteAsync(video.VideoCoverSavePath);
|
||
}
|
||
|
||
if (video.StorageType == StorageType.Local && !string.IsNullOrWhiteSpace(video.VideoSavePath))
|
||
{
|
||
string directory = Path.GetDirectoryName(video.VideoSavePath);
|
||
if (!string.IsNullOrWhiteSpace(directory) && Directory.Exists(directory) && Directory.GetFileSystemEntries(directory).Length == 0)
|
||
Directory.Delete(directory);
|
||
}
|
||
Log.Debug($"[{cookie.UserName}][{VideoType.GetDesc()}]-清理失败视频文件成功: {video.VideoSavePath}!!!");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log.Warning(ex, $"[{cookie.UserName}][{VideoType.GetDesc()}]-清理失败视频文件出错: {video.VideoSavePath}!!!");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 下载视频封面（重载）
|
||
/// 根据指定的封面URL下载封面图片，并复制为fanart.jpg
|
||
/// </summary>
|
||
/// <param name="coverUrl">封面图片URL</param>
|
||
/// <param name="savePath">封面保存文件夹</param>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <returns>一个表示异步操作的任务</returns>
|
||
private async Task<string> DownVideoCover(string coverUrl, string savePath, DouyinCookie cookie,AppConfig config)
|
||
{
|
||
if (config.CloseNfo) return string.Empty;
|
||
if (string.IsNullOrWhiteSpace(coverUrl)) return string.Empty;
|
||
if (string.IsNullOrWhiteSpace(savePath)) return string.Empty;
|
||
|
||
string directoryPath = ActiveStorageType.IsRemote() ? StoragePath.DirectoryName(savePath) : Path.GetDirectoryName(savePath);
|
||
string newFileName = "poster.jpg";
|
||
if (VideoType != VideoTypeEnum.dy_mix && VideoType != VideoTypeEnum.dy_series)
|
||
{
|
||
string fileNameWithoutExt = Path.GetFileNameWithoutExtension(savePath); // 获取无后缀的原文件名，
|
||
newFileName = $"{fileNameWithoutExt}-poster.jpg"; // 拼接新文件名，
|
||
}
|
||
|
||
var coverSavePath = CombineStoragePath(directoryPath, newFileName);
|
||
|
||
|
||
// 如果封面文件不存在，则下载
|
||
if (!await mediaStorageRouter.Resolve(ActiveStorageType).ExistsAsync(coverSavePath))
|
||
{
|
||
var result = await douyinHttpClientService.DownloadToStorageAsync(ActiveStorageType, coverUrl, coverSavePath, cookie.Cookies);
|
||
if (!result.Success)
|
||
{
|
||
_currentItemWarnings.Add($"封面下载失败（{result.SourceHost ?? "未知来源"}/{result.HttpStatusCode?.ToString() ?? result.FailureKind.ToString()}）");
|
||
return string.Empty;
|
||
}
|
||
coverSavePath = result.ActualSavePath;
|
||
}
|
||
return coverSavePath;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建视频实体
|
||
/// 根据视频信息、下载路径等创建DouyinVideo实体对象
|
||
/// </summary>
|
||
/// <param name="config">配置</param>
|
||
/// <param name="cookie">用户Cookie</param>
|
||
/// <param name="item">视频信息</param>
|
||
/// <param name="bitRate">视频码率信息</param>
|
||
/// <param name="savePath">视频保存路径</param>
|
||
/// <param name="coverSavePath">海报保存路径</param>
|
||
/// <param name="avatorPath"></param>
|
||
/// <param name="dynamicVideos">动态视频</param>
|
||
/// <param name="cate">短剧、合集、自定义收藏夹</param>
|
||
/// <returns>创建的视频实体对象</returns>
|
||
private async Task<DouyinVideo> CreateVideoEntity(AppConfig config,
|
||
DouyinCookie cookie, Aweme item, VideoBitRate bitRate, string savePath, string coverSavePath, string avatorPath, List<DouyinMergeVideoDto> dynamicVideos = null, DouyinCollectCate cate = null, bool onlyImgOrMp3 = false)
|
||
{
|
||
// 获取视频标签
|
||
var (tag1, tag2, tag3) = GetVideoTags(item);
|
||
var video = new DouyinVideo
|
||
{
|
||
ViedoType = VideoType,
|
||
StorageType = ActiveStorageType,
|
||
AwemeId = item.AwemeId,
|
||
Author = item.Author?.Nickname,
|
||
AuthorId = item.Author?.Uid,
|
||
AuthorAvatar = avatorPath,
|
||
AuthorAvatarUrl = item.Author?.AvatarLarger?.UrlList?.FirstOrDefault() ?? item.Author?.AvatarThumb?.UrlList?.FirstOrDefault(),
|
||
CreateTime = DateTimeUtil.Convert10BitTimestamp(item.CreateTime),
|
||
VideoTitle = string.IsNullOrWhiteSpace(item.Desc) ? $"{item.Author?.Nickname}-{item.CreateTime}" : item.Desc,
|
||
//VideoTitleSimplify = VideoType == VideoTypeEnum.dy_follows? GetVideoSimplifyTitle(item):string.Empty,
|
||
Id = IdGener.GetLong().ToString(),
|
||
Resolution = $"{bitRate?.PlayAddr?.Width ?? 0}×{bitRate?.PlayAddr?.Height ?? 0}",
|
||
FileSize = bitRate?.PlayAddr?.DataSize ?? 0,
|
||
FileHash = bitRate?.PlayAddr?.FileHash,
|
||
Tag1 = tag1,
|
||
Tag2 = tag2,
|
||
Tag3 = tag3,
|
||
VideoUrl = bitRate?.PlayAddr?.UrlList?.FirstOrDefault(),
|
||
VideoCoverUrl = item.Video?.Cover?.UrlList?.FirstOrDefault(),
|
||
VideoSavePath = savePath,
|
||
VideoCoverSavePath = coverSavePath,
|
||
SyncTime = DateTime.Now,
|
||
DyUserId = item.AuthorUserId == 0 ? item.Author?.Uid : item.AuthorUserId.ToString(),
|
||
CookieId = cookie.Id,
|
||
OnlyImgOrOnlyMp3 = onlyImgOrMp3,
|
||
CateId = cate?.Id,
|
||
CateXId = cate?.XId,
|
||
TaskItemId = _currentTaskItemId,
|
||
TaskWarning = _currentItemWarnings.Count == 0 ? null : string.Join("；", _currentItemWarnings.Distinct()),
|
||
};
|
||
if (cate != null && cate.CateType != VideoTypeEnum.dy_custom_collect)
|
||
{
|
||
video.VideoTitle = (string.IsNullOrWhiteSpace(item.Desc) ? cate.Name : $"[{cate.Name}]" + "_" + item.Desc)
|
||
+ "_" + (item.MixInfo?.Statis?.CurrentEpisode ?? 0);
|
||
}
|
||
if (dynamicVideos != null && dynamicVideos.Count > 0)
|
||
{
|
||
video.DynamicVideos = JsonConvert.SerializeObject(dynamicVideos);
|
||
}
|
||
else if (ActiveStorageType == StorageType.Local && !video.OnlyImgOrOnlyMp3)
|
||
{
|
||
if (cate != null && (VideoType == VideoTypeEnum.dy_mix || VideoType == VideoTypeEnum.dy_series))
|
||
{
|
||
NfoFileGenerator.GenerateVideoNfoFile(config.CloseNfo, video, cate.Name);
|
||
}
|
||
else
|
||
{
|
||
NfoFileGenerator.GenerateVideoNfoFile(config.CloseNfo, video);
|
||
}
|
||
}
|
||
|
||
if (ActiveStorageType.IsRemote() && (dynamicVideos == null || dynamicVideos.Count == 0))
|
||
await WriteRemoteNfoAsync(config, video, cate);
|
||
|
||
return video;
|
||
}
|
||
|
||
protected virtual void Dispose(bool disposing)
|
||
{
|
||
if (!disposedValue)
|
||
{
|
||
if (disposing)
|
||
{
|
||
// TODO: 释放托管状态(托管对象)
|
||
}
|
||
|
||
// TODO: 释放未托管的资源(未托管的对象)并重写终结器
|
||
// TODO: 将大型字段设置为 null
|
||
disposedValue = true;
|
||
}
|
||
}
|
||
|
||
// // TODO: 仅当“Dispose(bool disposing)”拥有用于释放未托管资源的代码时才替代终结器
|
||
// ~DouyinBasicSyncJob()
|
||
// {
|
||
// // 不要更改此代码。请将清理代码放入“Dispose(bool disposing)”方法中
|
||
// Dispose(disposing: false);
|
||
// }
|
||
|
||
public void Dispose()
|
||
{
|
||
// 不要更改此代码。请将清理代码放入“Dispose(bool disposing)”方法中
|
||
Dispose(disposing: true);
|
||
GC.SuppressFinalize(this);
|
||
}
|
||
|
||
#endregion
|
||
|
||
|
||
}
|
||
}
|