986 lines
36 KiB
C#
986 lines
36 KiB
C#
using System.Diagnostics;
|
||
using System.Text;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using MilliSim.Common.Dtos;
|
||
using MilliSim.Common.Entities;
|
||
using MilliSim.Common.Models;
|
||
using MilliSim.Data;
|
||
using MilliSim.Services.Infrastructure;
|
||
|
||
namespace MilliSim.Services;
|
||
|
||
public class SystemService : ISystemService
|
||
{
|
||
private readonly MilliSimDbContext _db;
|
||
private readonly IConfiguration _config;
|
||
private readonly IWebHostEnvironment _env;
|
||
private readonly IOperationLogService _operationLog;
|
||
private readonly IFileStorageService _fileStorage;
|
||
private readonly IUploadTrackingService _uploadTracking;
|
||
|
||
/// <summary>
|
||
/// 构造函数
|
||
/// </summary>
|
||
/// <param name="db">数据库上下文</param>
|
||
/// <param name="config">配置</param>
|
||
/// <param name="env">Web主机环境</param>
|
||
/// <param name="operationLog">操作日志服务</param>
|
||
/// <param name="fileStorage">文件存储服务</param>
|
||
/// <param name="uploadTracking">上传跟踪服务</param>
|
||
public SystemService(MilliSimDbContext db, IConfiguration config, IWebHostEnvironment env,
|
||
IOperationLogService operationLog, IFileStorageService fileStorage,
|
||
IUploadTrackingService uploadTracking)
|
||
{
|
||
_db = db;
|
||
_config = config;
|
||
_env = env;
|
||
_operationLog = operationLog;
|
||
_fileStorage = fileStorage;
|
||
_uploadTracking = uploadTracking;
|
||
}
|
||
|
||
// ===== 系统设置 =====
|
||
|
||
public async Task<ApiResponse<List<SystemSettingDto>>> GetSettingsAsync()
|
||
{
|
||
var settings = await _db.SystemSettings
|
||
.OrderBy(s => s.Id)
|
||
.Select(s => new SystemSettingDto
|
||
{
|
||
Key = s.Key,
|
||
Value = s.Value,
|
||
Description = s.Description
|
||
})
|
||
.ToListAsync();
|
||
|
||
// Logo 字段在 DB 中存储的是对象键，返回前需通过 GetSignedUrl 转换为可访问的 URL
|
||
var logoKeys = new[] { "LogoFrontend", "LogoBackend", "LogoFavicon", "LogoLogin", "LogoFooter" };
|
||
foreach (var s in settings)
|
||
{
|
||
if (logoKeys.Contains(s.Key) && !string.IsNullOrEmpty(s.Value))
|
||
{
|
||
s.Value = _fileStorage.GetSignedUrl(s.Value);
|
||
}
|
||
}
|
||
|
||
return ApiResponse<List<SystemSettingDto>>.Success(settings);
|
||
}
|
||
|
||
public async Task<ApiResponse> UpdateSettingsAsync(UpdateSettingsRequest request)
|
||
{
|
||
if (request.Settings == null || request.Settings.Count == 0)
|
||
return ApiResponse.Fail("没有需要更新的设置");
|
||
|
||
var keys = request.Settings.Keys.ToList();
|
||
var settings = await _db.SystemSettings
|
||
.Where(s => keys.Contains(s.Key))
|
||
.ToListAsync();
|
||
|
||
// Logo 五项的 key 集合（用于对比旧值并清理旧文件）
|
||
var logoKeys = new[] { "LogoFrontend", "LogoBackend", "LogoFavicon", "LogoLogin", "LogoFooter" };
|
||
|
||
// 保存前记录旧 Logo 值（用于对比变更后删除旧文件）
|
||
var oldLogoValues = new Dictionary<string, string>();
|
||
foreach (var setting in settings)
|
||
{
|
||
if (logoKeys.Contains(setting.Key))
|
||
{
|
||
oldLogoValues[setting.Key] = setting.Value;
|
||
}
|
||
}
|
||
|
||
foreach (var setting in settings)
|
||
{
|
||
if (request.Settings.TryGetValue(setting.Key, out var value))
|
||
{
|
||
// Logo 字段需通过 ExtractKey 转为对象键存储，避免签名 URL 过期导致数据丢失
|
||
setting.Value = logoKeys.Contains(setting.Key) ? _fileStorage.ExtractKey(value) : value;
|
||
setting.UpdatedAt = DateTime.Now;
|
||
}
|
||
}
|
||
|
||
await _db.SaveChangesAsync();
|
||
|
||
// 保存后对比 Logo 变化：替换则删旧文件，新文件消费标记
|
||
foreach (var logoKey in logoKeys)
|
||
{
|
||
if (!request.Settings.TryGetValue(logoKey, out var newValue)) continue;
|
||
|
||
var oldKey = _fileStorage.ExtractKey(oldLogoValues.GetValueOrDefault(logoKey) ?? "");
|
||
var newKey = _fileStorage.ExtractKey(newValue);
|
||
if (!string.IsNullOrEmpty(oldKey) && oldKey != newKey)
|
||
{
|
||
await _fileStorage.DeleteAsync(oldKey);
|
||
}
|
||
if (!string.IsNullOrEmpty(newKey))
|
||
{
|
||
await _uploadTracking.ConsumeAsync(newKey);
|
||
}
|
||
}
|
||
|
||
// 存储相关设置变更时清除缓存，确保后续请求读取最新配置
|
||
var storageKeys = new[] { "StorageMode", "CosSecretId", "CosSecretKey", "CosBucket", "CosRegion",
|
||
"CosSignedUrlExpireMinutes", "LocalBasePath", "LocalBaseUrl" };
|
||
if (request.Settings.Keys.Any(k => storageKeys.Contains(k)))
|
||
{
|
||
_fileStorage.ClearConfigCache();
|
||
}
|
||
|
||
await _operationLog.LogAsync("系统设置", "更新", $"更新了 {settings.Count} 项设置");
|
||
|
||
return ApiResponse.Success("设置更新成功");
|
||
}
|
||
|
||
public async Task<ApiResponse<SystemSettingDto>> GetSettingAsync(string key)
|
||
{
|
||
var setting = await _db.SystemSettings.FirstOrDefaultAsync(s => s.Key == key);
|
||
if (setting == null)
|
||
return ApiResponse<SystemSettingDto>.Fail("设置项不存在", 404);
|
||
|
||
return ApiResponse<SystemSettingDto>.Success(new SystemSettingDto
|
||
{
|
||
Key = setting.Key,
|
||
Value = setting.Value,
|
||
Description = setting.Description
|
||
});
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取公开系统设置（无需鉴权）：返回平台名、Logo（签名URL）、备案号等供前台显示
|
||
/// Logo 字段在库中存储的是上传时返回的签名URL，这里通过 ExtractKey + GetSignedUrl 刷新为最新签名URL，避免过期
|
||
/// </summary>
|
||
public async Task<ApiResponse<PublicSettingsDto>> GetPublicSettingsAsync()
|
||
{
|
||
var keys = new List<string>
|
||
{
|
||
"PlatformName", "Slogan", "CompanyName", "Contact", "ICP",
|
||
"ContactPhone", "ContactEmail", "ContactAddress", "ContactWebsite", "ContactWorkTime",
|
||
"LogoFrontend", "LogoBackend", "LogoFavicon", "LogoLogin", "LogoFooter",
|
||
"ShowPartners", "ShowAbout"
|
||
};
|
||
|
||
var settings = await _db.SystemSettings
|
||
.Where(s => keys.Contains(s.Key))
|
||
.Select(s => new { s.Key, s.Value })
|
||
.ToListAsync();
|
||
|
||
string Get(string key) => settings.FirstOrDefault(s => s.Key == key)?.Value ?? string.Empty;
|
||
|
||
string RefreshLogo(string key)
|
||
{
|
||
var raw = Get(key);
|
||
if (string.IsNullOrEmpty(raw)) return string.Empty;
|
||
var objectKey = _fileStorage.ExtractKey(raw);
|
||
return string.IsNullOrEmpty(objectKey) ? raw : _fileStorage.GetSignedUrl(objectKey);
|
||
}
|
||
|
||
var dto = new PublicSettingsDto
|
||
{
|
||
PlatformName = Get("PlatformName"),
|
||
Slogan = Get("Slogan"),
|
||
CompanyName = Get("CompanyName"),
|
||
Contact = Get("Contact"),
|
||
ContactPhone = Get("ContactPhone"),
|
||
ContactEmail = Get("ContactEmail"),
|
||
ContactAddress = Get("ContactAddress"),
|
||
ContactWebsite = Get("ContactWebsite"),
|
||
ContactWorkTime = Get("ContactWorkTime"),
|
||
ICP = Get("ICP"),
|
||
LogoFrontend = RefreshLogo("LogoFrontend"),
|
||
LogoBackend = RefreshLogo("LogoBackend"),
|
||
LogoFavicon = RefreshLogo("LogoFavicon"),
|
||
LogoLogin = RefreshLogo("LogoLogin"),
|
||
LogoFooter = RefreshLogo("LogoFooter"),
|
||
ShowPartners = Get("ShowPartners") != "false",
|
||
ShowAbout = Get("ShowAbout") != "false",
|
||
};
|
||
|
||
return ApiResponse<PublicSettingsDto>.Success(dto);
|
||
}
|
||
|
||
// ===== 关于我们内容管理 =====
|
||
|
||
/// <summary>
|
||
/// 获取关于我们设置（公开端点，前台 About 页消费）
|
||
/// </summary>
|
||
public async Task<ApiResponse<AboutSettingsDto>> GetAboutSettingsAsync()
|
||
{
|
||
var keys = new List<string> { "ShowAbout", "AboutContent" };
|
||
var settings = await _db.SystemSettings
|
||
.Where(s => keys.Contains(s.Key))
|
||
.Select(s => new { s.Key, s.Value })
|
||
.ToListAsync();
|
||
|
||
string Get(string key) => settings.FirstOrDefault(s => s.Key == key)?.Value ?? string.Empty;
|
||
|
||
var dto = new AboutSettingsDto
|
||
{
|
||
ShowAbout = Get("ShowAbout") != "false",
|
||
};
|
||
|
||
var contentJson = Get("AboutContent");
|
||
if (!string.IsNullOrEmpty(contentJson))
|
||
{
|
||
try
|
||
{
|
||
dto.Content = System.Text.Json.JsonSerializer.Deserialize<AboutContentDto>(contentJson) ?? new AboutContentDto();
|
||
// 刷新使命卡片图标的签名URL（存储的是COS对象键，读取时转换为签名URL）
|
||
if (dto.Content.MissionCards != null)
|
||
{
|
||
foreach (var card in dto.Content.MissionCards)
|
||
{
|
||
if (!string.IsNullOrEmpty(card.Icon) && card.Icon.Contains('/'))
|
||
{
|
||
card.Icon = _fileStorage.GetSignedUrl(card.Icon);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
dto.Content = new AboutContentDto();
|
||
}
|
||
}
|
||
|
||
return ApiResponse<AboutSettingsDto>.Success(dto);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新关于我们设置（Admin 端点）
|
||
/// </summary>
|
||
public async Task<ApiResponse> UpdateAboutSettingsAsync(AboutSettingsDto dto)
|
||
{
|
||
var keys = new List<string> { "ShowAbout", "AboutContent" };
|
||
var settings = await _db.SystemSettings
|
||
.Where(s => keys.Contains(s.Key))
|
||
.ToListAsync();
|
||
|
||
var settingDict = settings.ToDictionary(s => s.Key, s => s);
|
||
|
||
if (!settingDict.TryGetValue("ShowAbout", out var showAboutSetting))
|
||
{
|
||
showAboutSetting = new SystemSetting { Key = "ShowAbout", Description = "前台是否显示关于我们页面" };
|
||
_db.SystemSettings.Add(showAboutSetting);
|
||
}
|
||
showAboutSetting.Value = dto.ShowAbout ? "true" : "false";
|
||
showAboutSetting.UpdatedAt = DateTime.Now;
|
||
|
||
if (!settingDict.TryGetValue("AboutContent", out var contentSetting))
|
||
{
|
||
contentSetting = new SystemSetting { Key = "AboutContent", Description = "关于我们页面内容（JSON）" };
|
||
_db.SystemSettings.Add(contentSetting);
|
||
}
|
||
// 保存前将使命卡片图标的签名URL转换为COS对象键，避免签名过期
|
||
var contentToSave = dto.Content ?? new AboutContentDto();
|
||
if (contentToSave.MissionCards != null)
|
||
{
|
||
foreach (var card in contentToSave.MissionCards)
|
||
{
|
||
if (!string.IsNullOrEmpty(card.Icon))
|
||
{
|
||
card.Icon = _fileStorage.ExtractKey(card.Icon);
|
||
}
|
||
}
|
||
}
|
||
contentSetting.Value = System.Text.Json.JsonSerializer.Serialize(contentToSave);
|
||
contentSetting.UpdatedAt = DateTime.Now;
|
||
|
||
await _db.SaveChangesAsync();
|
||
await _operationLog.LogAsync("关于我们", "更新", "更新了关于我们页面内容");
|
||
|
||
return ApiResponse.Success("保存成功");
|
||
}
|
||
|
||
// ===== 工厂重置 =====
|
||
|
||
/// <summary>
|
||
/// 恢复出厂设置：清空所有业务数据（保留 admin 账户）+ 删除 COS 资源（保留 backups/）
|
||
/// 重置前自动创建数据库备份作为安全网
|
||
/// </summary>
|
||
public async Task<ApiResponse<FactoryResetResultDto>> FactoryResetAsync(FactoryResetRequest request)
|
||
{
|
||
if (request?.ConfirmText != "RESET")
|
||
{
|
||
return ApiResponse<FactoryResetResultDto>.Fail("确认文本不正确，请输入 RESET");
|
||
}
|
||
|
||
// 1. 重置前先创建数据库备份
|
||
var backupResult = await CreateBackupAsync();
|
||
var backupId = backupResult.Data?.Id ?? 0;
|
||
|
||
// 2. 列出所有 COS 对象（在清库前读取配置，保证配置可用）
|
||
// 容错：即使 COS 列举失败，仍继续清库，确保数据库恢复出厂状态
|
||
List<string> keysToDelete = new();
|
||
try
|
||
{
|
||
var allKeys = await _fileStorage.ListAllObjectsAsync();
|
||
// 过滤掉 backups/ 前缀（保留数据库备份作为安全网）
|
||
keysToDelete = allKeys.Where(k => !k.StartsWith("backups/", StringComparison.OrdinalIgnoreCase)).ToList();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
await _operationLog.LogAsync("工厂重置", "COS列举失败", $"列举对象失败，将继续清库。错误：{ex.Message}");
|
||
}
|
||
|
||
// 3. 清空所有业务表（保留 admin 账户）
|
||
var tables = new[]
|
||
{
|
||
"ProjectTagRelations", "ProjectScreenshots", "ProjectPackages",
|
||
"Favorites", "ExperienceLogs", "Authorizations",
|
||
"NotificationReads", "Notifications",
|
||
"Consultations", "OperationLogs",
|
||
"PendingUploads",
|
||
"Projects", "Banners", "Partners",
|
||
"ProjectCategories", "PlatformTypes", "FeatureTags",
|
||
"WakeProtocols",
|
||
"Backups",
|
||
"SystemSettings"
|
||
};
|
||
|
||
await _db.Database.ExecuteSqlRawAsync("SET FOREIGN_KEY_CHECKS = 0");
|
||
try
|
||
{
|
||
foreach (var table in tables)
|
||
{
|
||
await _db.Database.ExecuteSqlRawAsync("DELETE FROM `" + table + "`");
|
||
}
|
||
// Users 表：仅删除非 admin 用户，并清空 admin 的 avatar（避免引用已删除的 COS 文件）
|
||
await _db.Database.ExecuteSqlRawAsync("DELETE FROM `Users` WHERE `Username` != 'admin'");
|
||
await _db.Database.ExecuteSqlRawAsync("UPDATE `Users` SET `Avatar` = '' WHERE `Username` = 'admin'");
|
||
}
|
||
finally
|
||
{
|
||
await _db.Database.ExecuteSqlRawAsync("SET FOREIGN_KEY_CHECKS = 1");
|
||
}
|
||
|
||
// 4. 重新执行种子（admin 已存在跳过；分类/平台/标签/项目/轮播图/合作伙伴/设置按为空才补）
|
||
await DbSeeder.SeedAsync(_db);
|
||
|
||
// 5. 批量删除 COS 资源
|
||
var deletedCount = 0;
|
||
try
|
||
{
|
||
deletedCount = await _fileStorage.DeleteObjectsAsync(keysToDelete);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// COS 删除失败不回滚 DB（DB 已是干净状态），仅记录日志
|
||
await _operationLog.LogAsync("工厂重置", "COS清理失败", ex.Message);
|
||
}
|
||
|
||
await _operationLog.LogAsync("工厂重置", "执行", $"清空 {tables.Length + 1} 张表，删除 {deletedCount} 个 COS 对象，备份ID {backupId}");
|
||
|
||
return ApiResponse<FactoryResetResultDto>.Success(new FactoryResetResultDto
|
||
{
|
||
TablesCleared = tables.Length + 1, // +1 for Users
|
||
ObjectsDeleted = deletedCount,
|
||
BackupId = backupId
|
||
}, "工厂重置完成");
|
||
}
|
||
|
||
// ===== 操作日志 =====
|
||
|
||
public async Task<ApiResponse<PagedResult<OperationLogDto>>> GetOperationLogsAsync(OperationLogQueryRequest request)
|
||
{
|
||
var query = _db.OperationLogs.AsQueryable();
|
||
|
||
if (request.UserId.HasValue)
|
||
query = query.Where(l => l.UserId == request.UserId.Value);
|
||
|
||
if (!string.IsNullOrEmpty(request.Username))
|
||
query = query.Where(l => l.Username.Contains(request.Username));
|
||
|
||
if (!string.IsNullOrEmpty(request.Module))
|
||
query = query.Where(l => l.Module.Contains(request.Module));
|
||
|
||
if (request.StartDate.HasValue)
|
||
query = query.Where(l => l.CreatedAt >= request.StartDate.Value);
|
||
|
||
if (request.EndDate.HasValue)
|
||
query = query.Where(l => l.CreatedAt <= request.EndDate.Value);
|
||
|
||
if (!string.IsNullOrEmpty(request.Keyword))
|
||
query = query.Where(l =>
|
||
l.Username.Contains(request.Keyword) ||
|
||
l.Operation.Contains(request.Keyword) ||
|
||
l.Detail.Contains(request.Keyword));
|
||
|
||
var total = await query.CountAsync();
|
||
var logEntities = await query
|
||
.OrderByDescending(l => l.CreatedAt)
|
||
.Skip((request.PageIndex - 1) * request.PageSize)
|
||
.Take(request.PageSize)
|
||
.ToListAsync();
|
||
|
||
var userIds = logEntities.Select(l => l.UserId).Distinct().ToList();
|
||
var nicknames = await _db.Users
|
||
.Where(u => userIds.Contains(u.Id))
|
||
.ToDictionaryAsync(u => u.Id, u => u.Nickname);
|
||
|
||
var items = logEntities.Select(l => new OperationLogDto
|
||
{
|
||
Id = l.Id,
|
||
UserId = l.UserId,
|
||
Username = l.Username,
|
||
Nickname = nicknames.GetValueOrDefault(l.UserId) ?? string.Empty,
|
||
Module = l.Module,
|
||
Operation = l.Operation,
|
||
Detail = l.Detail,
|
||
Ip = l.Ip,
|
||
CreatedAt = l.CreatedAt
|
||
}).ToList();
|
||
|
||
return ApiResponse<PagedResult<OperationLogDto>>.Success(
|
||
PagedResult<OperationLogDto>.Create(items, total, request.PageIndex, request.PageSize));
|
||
}
|
||
|
||
public async Task<ApiResponse> ClearLogsAsync(DateTime? beforeDate)
|
||
{
|
||
int count;
|
||
if (beforeDate.HasValue)
|
||
{
|
||
count = await _db.OperationLogs
|
||
.Where(l => l.CreatedAt < beforeDate.Value)
|
||
.ExecuteDeleteAsync();
|
||
await _operationLog.LogAsync("操作日志", "清理", $"清理了 {beforeDate.Value:yyyy-MM-dd} 之前的日志 {count} 条");
|
||
}
|
||
else
|
||
{
|
||
count = await _db.OperationLogs.ExecuteDeleteAsync();
|
||
await _operationLog.LogAsync("操作日志", "清理", $"清空了全部日志 {count} 条");
|
||
}
|
||
|
||
return ApiResponse.Success($"已清理 {count} 条日志");
|
||
}
|
||
|
||
public async Task<ApiResponse> CleanExpiredLogsAsync()
|
||
{
|
||
var retentionDays = int.Parse(await GetSettingValueAsync("LogRetentionDays", "90"));
|
||
var cutoff = DateTime.Now.AddDays(-retentionDays);
|
||
var count = await _db.OperationLogs
|
||
.Where(l => l.CreatedAt < cutoff)
|
||
.ExecuteDeleteAsync();
|
||
return ApiResponse.Success($"已清理 {retentionDays} 天前的过期日志 {count} 条");
|
||
}
|
||
|
||
// ===== 数据备份 =====
|
||
|
||
public async Task<ApiResponse<List<BackupDto>>> GetBackupsAsync()
|
||
{
|
||
var backups = await _db.Backups
|
||
.OrderByDescending(b => b.CreatedAt)
|
||
.Select(b => new BackupDto
|
||
{
|
||
Id = b.Id,
|
||
FileName = b.FileName,
|
||
FileSize = b.FileSize,
|
||
Type = b.Type,
|
||
Url = b.Url,
|
||
CreatedAt = b.CreatedAt
|
||
})
|
||
.ToListAsync();
|
||
|
||
foreach (var b in backups)
|
||
{
|
||
b.Type = MapBackupType(b.Type);
|
||
}
|
||
|
||
return ApiResponse<List<BackupDto>>.Success(backups);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 将备份类型映射为中文：Manual->手动，Auto->自动，其余原样返回
|
||
/// </summary>
|
||
private static string MapBackupType(string type) => type switch
|
||
{
|
||
"Manual" => "手动",
|
||
"Auto" => "自动",
|
||
_ => string.IsNullOrEmpty(type) ? "手动" : type
|
||
};
|
||
|
||
public async Task<ApiResponse<BackupDto>> CreateBackupAsync()
|
||
{
|
||
// 生成本地备份文件
|
||
var dir = GetBackupDir();
|
||
var fileName = $"backup_{DateTime.Now:yyyyMMddHHmmss}.sql";
|
||
var filePath = Path.Combine(dir, fileName);
|
||
var localUrl = $"/backups/{fileName}";
|
||
|
||
// 尝试使用 mysqldump 导出
|
||
var success = await TryMySqlDumpAsync(filePath);
|
||
if (!success)
|
||
{
|
||
// 回退：使用 SQL 脚本生成
|
||
try
|
||
{
|
||
await GenerateSqlScriptAsync(filePath);
|
||
success = true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (File.Exists(filePath)) File.Delete(filePath);
|
||
return ApiResponse<BackupDto>.Fail($"备份失败：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
var fileInfo = new FileInfo(filePath);
|
||
// 在 COS 上传前先保存文件大小，避免上传后本地文件被删除导致 FileNotFoundException
|
||
var fileSize = fileInfo.Length;
|
||
|
||
// 读取存储模式（Local=本地存储，Cos=腾讯云COS）
|
||
var storageMode = await GetSettingValueAsync("StorageMode", "Cos");
|
||
string backupUrl = localUrl;
|
||
|
||
// 如果是COS模式，将备份文件上传到COS
|
||
if (storageMode.Equals("Cos", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
try
|
||
{
|
||
// 创建FormFile用于上传到COS
|
||
FileStream? fileStream = null;
|
||
try
|
||
{
|
||
fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
|
||
var formFile = new FormFile(fileStream, 0, fileStream.Length, "file", fileName)
|
||
{
|
||
Headers = new HeaderDictionary(),
|
||
ContentType = "application/sql"
|
||
};
|
||
|
||
// 上传备份文件到COS的backups目录
|
||
backupUrl = await _fileStorage.UploadAsync(formFile, "backups");
|
||
}
|
||
finally
|
||
{
|
||
// 确保文件流被关闭
|
||
fileStream?.Dispose();
|
||
}
|
||
|
||
// 上传成功后删除本地临时文件
|
||
if (File.Exists(filePath)) File.Delete(filePath);
|
||
}
|
||
catch
|
||
{
|
||
// COS上传失败，使用本地文件作为兜底
|
||
backupUrl = localUrl;
|
||
}
|
||
}
|
||
|
||
// 创建备份记录（使用预先保存的文件大小）
|
||
var backup = new Backup
|
||
{
|
||
FileName = fileName,
|
||
FileSize = fileSize,
|
||
Type = "Manual",
|
||
Url = backupUrl
|
||
};
|
||
_db.Backups.Add(backup);
|
||
await _db.SaveChangesAsync();
|
||
|
||
await _operationLog.LogAsync("数据备份", "创建", $"手动创建备份 {fileName}");
|
||
|
||
return ApiResponse<BackupDto>.Success(new BackupDto
|
||
{
|
||
Id = backup.Id,
|
||
FileName = backup.FileName,
|
||
FileSize = backup.FileSize,
|
||
Type = MapBackupType(backup.Type),
|
||
Url = backup.Url,
|
||
CreatedAt = backup.CreatedAt
|
||
});
|
||
}
|
||
|
||
public async Task<ApiResponse> DeleteBackupAsync(long id)
|
||
{
|
||
var backup = await _db.Backups.FindAsync(id);
|
||
if (backup == null)
|
||
return ApiResponse.Fail("备份不存在", 404);
|
||
|
||
// 判断备份文件存储位置（URL以"/"开头为本地文件，否则为COS对象键）
|
||
if (backup.Url.StartsWith("/"))
|
||
{
|
||
// 本地文件删除
|
||
var dir = GetBackupDir();
|
||
var filePath = Path.Combine(dir, backup.FileName);
|
||
if (File.Exists(filePath))
|
||
File.Delete(filePath);
|
||
}
|
||
else
|
||
{
|
||
// COS文件删除
|
||
await _fileStorage.DeleteAsync(backup.Url);
|
||
}
|
||
|
||
_db.Backups.Remove(backup);
|
||
await _db.SaveChangesAsync();
|
||
|
||
await _operationLog.LogAsync("数据备份", "删除", $"删除备份 {backup.FileName}");
|
||
|
||
return ApiResponse.Success("备份已删除");
|
||
}
|
||
|
||
public async Task<ApiResponse<(Stream Stream, string FileName)>> DownloadBackupAsync(long id)
|
||
{
|
||
var backup = await _db.Backups.FindAsync(id);
|
||
if (backup == null)
|
||
return ApiResponse<(Stream, string)>.Fail("备份不存在", 404);
|
||
|
||
// 判断备份文件存储位置（URL以"/"开头为本地文件，否则为COS对象键）
|
||
if (backup.Url.StartsWith("/"))
|
||
{
|
||
// 本地文件下载
|
||
var dir = GetBackupDir();
|
||
var filePath = Path.Combine(dir, backup.FileName);
|
||
if (!File.Exists(filePath))
|
||
return ApiResponse<(Stream, string)>.Fail("备份文件不存在", 404);
|
||
|
||
var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
|
||
return ApiResponse<(Stream, string)>.Success((stream, backup.FileName));
|
||
}
|
||
else
|
||
{
|
||
// COS文件下载
|
||
try
|
||
{
|
||
var (stream, _, _) = await _fileStorage.DownloadAsync(backup.Url);
|
||
return ApiResponse<(Stream, string)>.Success((stream, backup.FileName));
|
||
}
|
||
catch
|
||
{
|
||
return ApiResponse<(Stream, string)>.Fail("备份文件不存在", 404);
|
||
}
|
||
}
|
||
}
|
||
|
||
public async Task CleanExpiredBackupsAsync()
|
||
{
|
||
// 读取备份保留天数
|
||
var retentionDays = int.Parse(await GetSettingValueAsync("BackupRetentionDays", "30"));
|
||
var cutoff = DateTime.Now.AddDays(-retentionDays);
|
||
// 查询过期备份
|
||
var expired = await _db.Backups
|
||
.Where(b => b.CreatedAt < cutoff)
|
||
.ToListAsync();
|
||
|
||
// 遍历删除过期备份文件
|
||
foreach (var b in expired)
|
||
{
|
||
// 判断备份文件存储位置（URL以"/"开头为本地文件，否则为COS对象键）
|
||
if (b.Url.StartsWith("/"))
|
||
{
|
||
// 本地文件删除
|
||
var dir = GetBackupDir();
|
||
var filePath = Path.Combine(dir, b.FileName);
|
||
if (File.Exists(filePath))
|
||
File.Delete(filePath);
|
||
}
|
||
else
|
||
{
|
||
// COS文件删除
|
||
await _fileStorage.DeleteAsync(b.Url);
|
||
}
|
||
}
|
||
|
||
// 删除数据库记录
|
||
_db.Backups.RemoveRange(expired);
|
||
await _db.SaveChangesAsync();
|
||
}
|
||
|
||
// ===== 唤醒协议 =====
|
||
|
||
public async Task<ApiResponse<List<WakeProtocolDto>>> GetWakeProtocolsAsync()
|
||
{
|
||
var list = await _db.WakeProtocols
|
||
.OrderBy(w => w.Id)
|
||
.Select(w => new WakeProtocolDto
|
||
{
|
||
Id = w.Id,
|
||
TerminalType = w.TerminalType,
|
||
ProtocolPrefix = w.ProtocolPrefix,
|
||
ParamTemplate = w.ParamTemplate,
|
||
Status = w.Status
|
||
})
|
||
.ToListAsync();
|
||
return ApiResponse<List<WakeProtocolDto>>.Success(list);
|
||
}
|
||
|
||
public async Task<ApiResponse<WakeProtocolDto>> CreateWakeProtocolAsync(CreateWakeProtocolRequest request)
|
||
{
|
||
var wp = new WakeProtocol
|
||
{
|
||
TerminalType = request.TerminalType,
|
||
ProtocolPrefix = request.ProtocolPrefix,
|
||
ParamTemplate = request.ParamTemplate,
|
||
Status = request.Status
|
||
};
|
||
_db.WakeProtocols.Add(wp);
|
||
await _db.SaveChangesAsync();
|
||
|
||
await _operationLog.LogAsync("唤醒协议", "创建", $"创建唤醒协议 {wp.TerminalType}");
|
||
|
||
return ApiResponse<WakeProtocolDto>.Success(MapToDto(wp));
|
||
}
|
||
|
||
public async Task<ApiResponse<WakeProtocolDto>> UpdateWakeProtocolAsync(long id, CreateWakeProtocolRequest request)
|
||
{
|
||
var wp = await _db.WakeProtocols.FindAsync(id);
|
||
if (wp == null)
|
||
return ApiResponse<WakeProtocolDto>.Fail("唤醒协议不存在", 404);
|
||
|
||
wp.TerminalType = request.TerminalType;
|
||
wp.ProtocolPrefix = request.ProtocolPrefix;
|
||
wp.ParamTemplate = request.ParamTemplate;
|
||
wp.Status = request.Status;
|
||
wp.UpdatedAt = DateTime.Now;
|
||
|
||
await _db.SaveChangesAsync();
|
||
await _operationLog.LogAsync("唤醒协议", "更新", $"更新唤醒协议 {wp.TerminalType}");
|
||
|
||
return ApiResponse<WakeProtocolDto>.Success(MapToDto(wp));
|
||
}
|
||
|
||
public async Task<ApiResponse> DeleteWakeProtocolAsync(long id)
|
||
{
|
||
var wp = await _db.WakeProtocols.FindAsync(id);
|
||
if (wp == null)
|
||
return ApiResponse.Fail("唤醒协议不存在", 404);
|
||
|
||
wp.IsDeleted = true;
|
||
wp.UpdatedAt = DateTime.Now;
|
||
await _db.SaveChangesAsync();
|
||
|
||
await _operationLog.LogAsync("唤醒协议", "删除", $"删除唤醒协议 {wp.TerminalType}");
|
||
|
||
return ApiResponse.Success("删除成功");
|
||
}
|
||
|
||
// ===== 本地存储目录测试 =====
|
||
|
||
/// <summary>
|
||
/// 测试本地存储目录是否可读写（保存存储配置前校验）
|
||
/// 支持相对路径（相对于 ContentRootPath）或绝对路径
|
||
/// </summary>
|
||
public Task<ApiResponse> TestLocalPathAsync(string localBasePath)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(localBasePath))
|
||
return Task.FromResult(ApiResponse.Fail("存储根目录不能为空"));
|
||
|
||
try
|
||
{
|
||
// 解析为绝对路径
|
||
var absolutePath = Path.IsPathRooted(localBasePath)
|
||
? localBasePath
|
||
: Path.Combine(_env.ContentRootPath, localBasePath);
|
||
|
||
// 确保目录存在
|
||
Directory.CreateDirectory(absolutePath);
|
||
|
||
// 测试写入
|
||
var testFile = Path.Combine(absolutePath, $".millisim_test_{Guid.NewGuid():N}");
|
||
File.WriteAllText(testFile, "test");
|
||
// 测试读取
|
||
var content = File.ReadAllText(testFile);
|
||
// 清理测试文件
|
||
File.Delete(testFile);
|
||
|
||
if (content != "test")
|
||
return Task.FromResult(ApiResponse.Fail("目录可写但读取内容不匹配，请检查目录权限"));
|
||
|
||
return Task.FromResult(ApiResponse.Success($"目录可读写：{absolutePath}"));
|
||
}
|
||
catch (UnauthorizedAccessException)
|
||
{
|
||
return Task.FromResult(ApiResponse.Fail("目录无访问权限，请选择其他目录或修改权限"));
|
||
}
|
||
catch (ArgumentException ex)
|
||
{
|
||
return Task.FromResult(ApiResponse.Fail($"路径格式无效：{ex.Message}"));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return Task.FromResult(ApiResponse.Fail($"目录测试失败：{ex.Message}"));
|
||
}
|
||
}
|
||
|
||
// ===== 辅助方法 =====
|
||
|
||
private async Task<string> GetSettingValueAsync(string key, string defaultValue)
|
||
{
|
||
var setting = await _db.SystemSettings.FirstOrDefaultAsync(s => s.Key == key);
|
||
return setting?.Value ?? defaultValue;
|
||
}
|
||
|
||
private string GetBackupDir()
|
||
{
|
||
var root = _env.WebRootPath ?? Path.Combine(_env.ContentRootPath, "wwwroot");
|
||
var dir = Path.Combine(root, "backups");
|
||
Directory.CreateDirectory(dir);
|
||
return dir;
|
||
}
|
||
|
||
private static WakeProtocolDto MapToDto(WakeProtocol wp) => new()
|
||
{
|
||
Id = wp.Id,
|
||
TerminalType = wp.TerminalType,
|
||
ProtocolPrefix = wp.ProtocolPrefix,
|
||
ParamTemplate = wp.ParamTemplate,
|
||
Status = wp.Status
|
||
};
|
||
|
||
/// <summary>
|
||
/// 尝试使用 mysqldump 导出数据库
|
||
/// </summary>
|
||
private async Task<bool> TryMySqlDumpAsync(string filePath)
|
||
{
|
||
try
|
||
{
|
||
var connectionString = _config.GetConnectionString("DefaultConnection")!;
|
||
var builder = new MySqlConnector.MySqlConnectionStringBuilder(connectionString);
|
||
var host = builder.Server;
|
||
var port = builder.Port;
|
||
var database = builder.Database;
|
||
var user = builder.UserID;
|
||
var password = builder.Password;
|
||
|
||
var args = new StringBuilder();
|
||
args.Append($"-h{host} -P{port} -u{user}");
|
||
if (!string.IsNullOrEmpty(password))
|
||
args.Append($" -p\"{password}\"");
|
||
args.Append(" --default-character-set=utf8mb4 --single-transaction --routines --triggers --skip-lock-tables");
|
||
args.Append($" \"{database}\"");
|
||
|
||
var psi = new ProcessStartInfo
|
||
{
|
||
FileName = "mysqldump",
|
||
Arguments = args.ToString(),
|
||
UseShellExecute = false,
|
||
RedirectStandardOutput = true,
|
||
RedirectStandardError = true,
|
||
CreateNoWindow = true
|
||
};
|
||
|
||
using var process = Process.Start(psi);
|
||
if (process == null) return false;
|
||
|
||
// 并发读取 stderr 防止缓冲区死锁
|
||
var stderrTask = process.StandardError.ReadToEndAsync();
|
||
|
||
await using (var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write))
|
||
{
|
||
await process.StandardOutput.BaseStream.CopyToAsync(fileStream);
|
||
await fileStream.FlushAsync();
|
||
}
|
||
|
||
await process.WaitForExitAsync();
|
||
await stderrTask;
|
||
|
||
if (process.ExitCode != 0)
|
||
{
|
||
if (File.Exists(filePath)) File.Delete(filePath);
|
||
return false;
|
||
}
|
||
|
||
var fi = new FileInfo(filePath);
|
||
if (fi.Length == 0)
|
||
{
|
||
File.Delete(filePath);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
catch
|
||
{
|
||
if (File.Exists(filePath)) File.Delete(filePath);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 回退方案：直接查询数据库生成 SQL 脚本
|
||
/// </summary>
|
||
private async Task GenerateSqlScriptAsync(string filePath)
|
||
{
|
||
var connectionString = _config.GetConnectionString("DefaultConnection")!;
|
||
await using var connection = new MySqlConnector.MySqlConnection(connectionString);
|
||
await connection.OpenAsync();
|
||
|
||
var sb = new StringBuilder();
|
||
sb.AppendLine("-- MilliSim Database Backup");
|
||
sb.AppendLine($"-- Generated: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
|
||
sb.AppendLine("SET NAMES utf8mb4;");
|
||
sb.AppendLine("SET FOREIGN_KEY_CHECKS=0;");
|
||
sb.AppendLine();
|
||
|
||
var tables = new List<string>();
|
||
await using (var cmd = connection.CreateCommand())
|
||
{
|
||
cmd.CommandText = "SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'";
|
||
await using var reader = await cmd.ExecuteReaderAsync();
|
||
while (await reader.ReadAsync())
|
||
{
|
||
tables.Add(reader.GetString(0));
|
||
}
|
||
}
|
||
|
||
foreach (var table in tables)
|
||
{
|
||
// 表结构
|
||
await using (var createCmd = connection.CreateCommand())
|
||
{
|
||
createCmd.CommandText = $"SHOW CREATE TABLE `{table}`";
|
||
await using var createReader = await createCmd.ExecuteReaderAsync();
|
||
if (await createReader.ReadAsync())
|
||
{
|
||
sb.AppendLine($"-- ----------------------------");
|
||
sb.AppendLine($"-- Table structure for {table}");
|
||
sb.AppendLine($"-- ----------------------------");
|
||
sb.AppendLine($"DROP TABLE IF EXISTS `{table}`;");
|
||
sb.AppendLine(createReader.GetString(1) + ";");
|
||
sb.AppendLine();
|
||
}
|
||
}
|
||
|
||
// 表数据
|
||
await using (var dataCmd = connection.CreateCommand())
|
||
{
|
||
dataCmd.CommandText = $"SELECT * FROM `{table}`";
|
||
await using var dataReader = await dataCmd.ExecuteReaderAsync();
|
||
var columns = new List<string>();
|
||
for (var i = 0; i < dataReader.FieldCount; i++)
|
||
{
|
||
columns.Add(dataReader.GetName(i));
|
||
}
|
||
|
||
var hasData = false;
|
||
while (await dataReader.ReadAsync())
|
||
{
|
||
hasData = true;
|
||
var values = new List<string>();
|
||
for (var i = 0; i < dataReader.FieldCount; i++)
|
||
{
|
||
values.Add(FormatSqlValue(dataReader.GetValue(i)));
|
||
}
|
||
sb.AppendLine($"INSERT INTO `{table}` (`{string.Join("`, `", columns)}`) VALUES ({string.Join(", ", values)});");
|
||
}
|
||
if (hasData) sb.AppendLine();
|
||
}
|
||
}
|
||
|
||
sb.AppendLine("SET FOREIGN_KEY_CHECKS=1;");
|
||
|
||
await File.WriteAllTextAsync(filePath, sb.ToString());
|
||
}
|
||
|
||
private static string FormatSqlValue(object? value)
|
||
{
|
||
if (value == null || value == DBNull.Value) return "NULL";
|
||
if (value is bool b) return b ? "1" : "0";
|
||
if (value is DateTime dt) return $"'{dt:yyyy-MM-dd HH:mm:ss}'";
|
||
if (value is byte[] bytes) return $"0x{Convert.ToHexString(bytes)}";
|
||
if (value is sbyte or short or int or long or byte or ushort or uint or ulong) return value.ToString()!;
|
||
if (value is float or double or decimal) return value.ToString()!;
|
||
var s = value.ToString() ?? string.Empty;
|
||
return "'" + s.Replace("\\", "\\\\").Replace("'", "\\'").Replace("\n", "\\n").Replace("\r", "\\r") + "'";
|
||
}
|
||
}
|