939 lines
43 KiB
C#
939 lines
43 KiB
C#
using System.Drawing;
|
||
using YD_Event.Application.Auth;
|
||
using YD_Event.Application.Common.Excel;
|
||
using YD_Event.Application.OrderBook.Dtos;
|
||
using YD_Event.Core.Domain.Export;
|
||
|
||
namespace YD_Event.Application.OrderBook;
|
||
|
||
/// <summary>
|
||
/// 秩序册导入接口（下载模板 / 同步解析 / 确认落库）
|
||
/// </summary>
|
||
[ApiDescriptionSettings("打分系统", Name = "order-book")]
|
||
[Route("api/orderbook")]
|
||
[Authorize]
|
||
public class OrderBookService : IDynamicApiController, ITransient
|
||
{
|
||
private const string EntrySheetName = "出场秩序";
|
||
private const string RefereeSheetName = "裁判名单";
|
||
private static readonly TimeSpan BatchTtl = TimeSpan.FromMinutes(30);
|
||
|
||
private readonly ISqlSugarRepository<EventInfo> _eventRepository;
|
||
private readonly ISqlSugarRepository<Core.Entities.Project> _projectRepository;
|
||
private readonly ISqlSugarRepository<EventProject> _eventProjectRepository;
|
||
private readonly ISqlSugarRepository<EventProjectGroup> _groupRepository;
|
||
private readonly ISqlSugarRepository<ProjectGroup> _projectGroupRepository;
|
||
private readonly ISqlSugarRepository<EventVenue> _venueRepository;
|
||
private readonly ISqlSugarRepository<EventSession> _sessionRepository;
|
||
private readonly ISqlSugarRepository<EventSessionEntry> _entryRepository;
|
||
private readonly ISqlSugarRepository<Core.Entities.ScoreRule> _scoreRuleRepository;
|
||
private readonly ISqlSugarRepository<EventJudgeAssignment> _judgeAssignmentRepository;
|
||
private readonly ISqlSugarRepository<Core.Entities.Referee> _refereeRepository;
|
||
private readonly ISqlSugarRepository<EventReferee> _eventRefereeRepository;
|
||
private readonly ISqlSugarRepository<Core.Entities.AppUser> _appUserRepository;
|
||
private readonly IEasyCachingProvider _cache;
|
||
private readonly IIdGenerator _idGenerator;
|
||
private readonly AuthManager _authManager;
|
||
|
||
public OrderBookService(
|
||
ISqlSugarRepository<EventInfo> eventRepository,
|
||
ISqlSugarRepository<Core.Entities.Project> projectRepository,
|
||
ISqlSugarRepository<EventProject> eventProjectRepository,
|
||
ISqlSugarRepository<EventProjectGroup> groupRepository,
|
||
ISqlSugarRepository<ProjectGroup> projectGroupRepository,
|
||
ISqlSugarRepository<EventVenue> venueRepository,
|
||
ISqlSugarRepository<EventSession> sessionRepository,
|
||
ISqlSugarRepository<EventSessionEntry> entryRepository,
|
||
ISqlSugarRepository<Core.Entities.ScoreRule> scoreRuleRepository,
|
||
ISqlSugarRepository<EventJudgeAssignment> judgeAssignmentRepository,
|
||
ISqlSugarRepository<Core.Entities.Referee> refereeRepository,
|
||
ISqlSugarRepository<EventReferee> eventRefereeRepository,
|
||
ISqlSugarRepository<Core.Entities.AppUser> appUserRepository,
|
||
IEasyCachingProvider cache,
|
||
IIdGenerator idGenerator,
|
||
AuthManager authManager)
|
||
{
|
||
_eventRepository = eventRepository;
|
||
_projectRepository = projectRepository;
|
||
_eventProjectRepository = eventProjectRepository;
|
||
_groupRepository = groupRepository;
|
||
_projectGroupRepository = projectGroupRepository;
|
||
_venueRepository = venueRepository;
|
||
_sessionRepository = sessionRepository;
|
||
_entryRepository = entryRepository;
|
||
_scoreRuleRepository = scoreRuleRepository;
|
||
_judgeAssignmentRepository = judgeAssignmentRepository;
|
||
_refereeRepository = refereeRepository;
|
||
_eventRefereeRepository = eventRefereeRepository;
|
||
_appUserRepository = appUserRepository;
|
||
_cache = cache;
|
||
_idGenerator = idGenerator;
|
||
_authManager = authManager;
|
||
}
|
||
|
||
#region 下载模板
|
||
|
||
/// <summary>
|
||
/// 下载秩序册导入模板
|
||
/// </summary>
|
||
/// <param name="projectMode"></param>
|
||
/// <returns></returns>
|
||
[DisplayName("下载秩序册导入模板")]
|
||
[HttpGet("template")]
|
||
public async Task<IActionResult> DownloadTemplate([FromQuery] string? projectMode)
|
||
{
|
||
var scoreRuleNames = await _scoreRuleRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && x.Status == AvailabilityStatus.Enable)
|
||
.Select(x => x.RuleName)
|
||
.ToListAsync();
|
||
scoreRuleNames = scoreRuleNames
|
||
.Where(x => !string.IsNullOrWhiteSpace(x))
|
||
.Distinct(StringComparer.Ordinal)
|
||
.OrderBy(x => x, StringComparer.Ordinal)
|
||
.ToList();
|
||
if (scoreRuleNames.Count == 0)
|
||
throw Oops.Bah("当前没有已启用的计分规则，请先配置计分规则后再下载模板");
|
||
|
||
var bytes = await new OrderBookTemplateExporter(scoreRuleNames).ExportAsync();
|
||
return new FileContentResult(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
|
||
{
|
||
FileDownloadName = "秩序册导入模板.xlsx"
|
||
};
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 同步解析
|
||
|
||
/// <summary>
|
||
/// 上传并同步解析秩序册（不产生业务数据，结果缓存待确认）
|
||
/// </summary>
|
||
/// <param name="eventId"></param>
|
||
/// <param name="importMode"></param>
|
||
/// <param name="file"></param>
|
||
/// <returns></returns>
|
||
[DisplayName("解析秩序册")]
|
||
[HttpPost("import")]
|
||
public async Task<OrderBookImportOutput> Import(long? eventId, string? importMode, IFormFile file)
|
||
{
|
||
if (file == null || file.Length == 0)
|
||
throw Oops.Bah("请上传秩序册文件");
|
||
|
||
var ext = Path.GetExtension(file.FileName)?.ToLowerInvariant();
|
||
if (ext is not ".xlsx" and not ".xls")
|
||
throw Oops.Bah("仅支持 .xls/.xlsx 格式的秩序册文件");
|
||
|
||
if (!eventId.HasValue || eventId.Value <= 0)
|
||
throw Oops.Bah("请先选择已配置项目和组别的赛事，再上传秩序册");
|
||
if (!await _eventRepository.IsAnyAsync(e => e.Id == eventId.Value && !e.DeleteMark))
|
||
throw Oops.Bah("赛事不存在或已删除");
|
||
|
||
var mode = string.IsNullOrWhiteSpace(importMode) ? "overwrite" : importMode.Trim().ToLowerInvariant();
|
||
if (mode != "append" && mode != "overwrite")
|
||
throw Oops.Bah("导入模式只能为 append（追加）或 overwrite（覆盖）");
|
||
|
||
List<OrderBookEntryRow> entryRows;
|
||
List<OrderBookRefereeRow> refereeRows;
|
||
try
|
||
{
|
||
using var stream = file.OpenReadStream();
|
||
// NPOI 统一读取，WorkbookFactory 按文件头自动识别 .xls/.xlsx
|
||
using var workbook = NpoiExcelReader.CreateWorkbook(stream);
|
||
entryRows = NpoiExcelReader.ReadSheet<OrderBookEntryRow>(workbook, EntrySheetName);
|
||
refereeRows = NpoiExcelReader.ReadSheet<OrderBookRefereeRow>(workbook, RefereeSheetName);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw Oops.Bah($"秩序册解析失败，请确认包含「{EntrySheetName}」「{RefereeSheetName}」两个工作表：{ex.Message}");
|
||
}
|
||
|
||
var issues = new List<OrderBookParseIssue>();
|
||
var draftEntries = ParseEntryRows(entryRows, issues);
|
||
var draftReferees = ParseRefereeRows(refereeRows, issues);
|
||
if (draftEntries.Count == 0)
|
||
issues.Add(Issue(0, "出场秩序", "秩序册没有可导入的出场数据"));
|
||
var catalog = await LoadProjectCatalogAsync(draftEntries, eventId.Value);
|
||
issues.AddRange(ValidateProjects(draftEntries, catalog));
|
||
if (mode == "append") await ValidateAppendRulesAsync(draftEntries, eventId.Value, issues);
|
||
await ValidateRefereesAsync(draftReferees, issues);
|
||
|
||
var errorCount = issues.Count(i => i.Level == "error");
|
||
var warningCount = issues.Count(i => i.Level == "warning");
|
||
|
||
var draft = new OrderBookDraft
|
||
{
|
||
BatchId = _idGenerator.NextId(),
|
||
CreatedUserId = _authManager.UserId,
|
||
HasErrors = errorCount > 0,
|
||
EventId = eventId,
|
||
ImportMode = mode,
|
||
CreatedAt = DateTime.Now,
|
||
Entries = draftEntries,
|
||
Referees = draftReferees
|
||
};
|
||
|
||
var preview = BuildPreview(draft);
|
||
|
||
// 重传覆盖：同一赛事存在旧的未确认批次时移除，始终以最新一次上传为准
|
||
if (eventId.HasValue)
|
||
{
|
||
var currentKey = CurrentKey(eventId.Value, _authManager.UserId);
|
||
var oldBatch = await _cache.GetAsync<long>(currentKey);
|
||
if (oldBatch.HasValue)
|
||
await _cache.RemoveAsync(BatchKey(oldBatch.Value));
|
||
await _cache.SetAsync(currentKey, draft.BatchId, BatchTtl);
|
||
}
|
||
await _cache.SetAsync(BatchKey(draft.BatchId), draft, BatchTtl);
|
||
|
||
return new OrderBookImportOutput
|
||
{
|
||
BatchId = draft.BatchId,
|
||
Status = errorCount > 0 ? 20 : 10,
|
||
TotalRows = entryRows.Count + refereeRows.Count,
|
||
ValidRows = draft.Entries.Count(e => !issues.Any(i => i.Level == "error" && i.Row == e.Row && i.Sheet == EntrySheetName))
|
||
+ draft.Referees.Count(r => !issues.Any(i => i.Level == "error" && i.Row == r.Row && i.Sheet == RefereeSheetName)),
|
||
ErrorCount = errorCount,
|
||
WarningCount = warningCount,
|
||
Preview = preview,
|
||
Errors = issues
|
||
};
|
||
}
|
||
|
||
private static List<OrderBookDraftEntry> ParseEntryRows(List<OrderBookEntryRow> rows, List<OrderBookParseIssue> issues)
|
||
{
|
||
var result = new List<OrderBookDraftEntry>();
|
||
for (var i = 0; i < rows.Count; i++)
|
||
{
|
||
var row = rows[i];
|
||
var rowNo = row.ExcelRowNumber > 0 ? row.ExcelRowNumber : i + 3;
|
||
|
||
// 整行为空直接跳过
|
||
if (IsAllBlank(row.ProjectName, row.ScoreRuleName, row.GroupName, row.ParticipantName,
|
||
row.TeamName, row.UnitName, row.SessionName, row.VenueName))
|
||
continue;
|
||
|
||
var project = Trim(row.ProjectName);
|
||
var scoreRule = Trim(row.ScoreRuleName);
|
||
var group = Trim(row.GroupName);
|
||
var participant = Trim(row.ParticipantName);
|
||
var session = Trim(row.SessionName);
|
||
var venue = Trim(row.VenueName);
|
||
|
||
if (string.IsNullOrWhiteSpace(project))
|
||
issues.Add(Issue(rowNo, "项目名称", "项目名称为必填项"));
|
||
if (string.IsNullOrWhiteSpace(scoreRule))
|
||
issues.Add(Issue(rowNo, "计分规则", "计分规则为必填项"));
|
||
if (string.IsNullOrWhiteSpace(group))
|
||
issues.Add(Issue(rowNo, "组别名称", "组别名称为必填项"));
|
||
if (string.IsNullOrWhiteSpace(participant))
|
||
issues.Add(Issue(rowNo, "姓名", "姓名为必填项"));
|
||
if (string.IsNullOrWhiteSpace(session))
|
||
issues.Add(Issue(rowNo, "场次", "场次为必填项"));
|
||
if (string.IsNullOrWhiteSpace(venue))
|
||
issues.Add(Issue(rowNo, "场地", "场地为必填项"));
|
||
|
||
result.Add(new OrderBookDraftEntry
|
||
{
|
||
Row = rowNo,
|
||
VenueName = venue,
|
||
ProjectName = project,
|
||
ScoreRuleName = scoreRule,
|
||
GroupName = group,
|
||
SessionName = session,
|
||
ParticipantName = participant,
|
||
TeamName = Trim(row.TeamName),
|
||
UnitName = Trim(row.UnitName)
|
||
});
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private static List<OrderBookDraftReferee> ParseRefereeRows(List<OrderBookRefereeRow> rows, List<OrderBookParseIssue> issues)
|
||
{
|
||
var result = new List<OrderBookDraftReferee>();
|
||
var seenMobiles = new HashSet<string>();
|
||
for (var i = 0; i < rows.Count; i++)
|
||
{
|
||
var row = rows[i];
|
||
var rowNo = row.ExcelRowNumber > 0 ? row.ExcelRowNumber : i + 3;
|
||
|
||
if (IsAllBlank(row.Name, row.Mobile))
|
||
continue;
|
||
|
||
var name = Trim(row.Name);
|
||
var mobile = Trim(row.Mobile);
|
||
|
||
if (string.IsNullOrWhiteSpace(name))
|
||
issues.Add(RefereeIssue(rowNo, "姓名", "裁判姓名为必填项"));
|
||
if (string.IsNullOrWhiteSpace(mobile))
|
||
issues.Add(RefereeIssue(rowNo, "手机号", "裁判手机号为必填项"));
|
||
else if (!Regex.IsMatch(mobile, @"^1[3-9]\d{9}$"))
|
||
issues.Add(RefereeIssue(rowNo, "手机号", $"裁判手机号「{mobile}」格式不正确"));
|
||
|
||
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(mobile) ||
|
||
!Regex.IsMatch(mobile, @"^1[3-9]\d{9}$"))
|
||
continue;
|
||
if (!seenMobiles.Add(mobile))
|
||
{
|
||
issues.Add(RefereeIssue(rowNo, "手机号", $"裁判手机号「{mobile}」重复，已自动合并", "warning"));
|
||
continue;
|
||
}
|
||
|
||
result.Add(new OrderBookDraftReferee
|
||
{
|
||
Row = rowNo,
|
||
Name = name!,
|
||
Mobile = mobile!
|
||
});
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private static OrderBookPreview BuildPreview(OrderBookDraft draft)
|
||
{
|
||
return new OrderBookPreview
|
||
{
|
||
VenueCount = draft.Entries.Select(e => e.VenueName).Where(v => !string.IsNullOrWhiteSpace(v)).Distinct().Count(),
|
||
SessionCount = draft.Entries
|
||
.Select(e => (e.ProjectName, e.ScoreRuleName, e.GroupName, e.SessionName, e.VenueName))
|
||
.Distinct().Count(),
|
||
EntryCount = draft.Entries.Count,
|
||
RefereeCount = draft.Referees.Select(r => r.Mobile).Distinct().Count()
|
||
};
|
||
}
|
||
|
||
private async Task<OrderBookProjectCatalog> LoadProjectCatalogAsync(
|
||
List<OrderBookDraftEntry> entries, long eventId)
|
||
{
|
||
var projectNames = entries.Select(x => x.ProjectName).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
|
||
var ruleNames = entries.Select(x => x.ScoreRuleName).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
|
||
var projects = await _projectRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && projectNames.Contains(x.Name.Trim())).ToListAsync();
|
||
var rules = await _scoreRuleRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && ruleNames.Contains(x.RuleName.Trim())).ToListAsync();
|
||
var projectIds = projects.Select(x => x.Id).ToList();
|
||
var eventProjects = await _eventProjectRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && x.EventId == eventId && projectIds.Contains(x.ProjectId)).ToListAsync();
|
||
var projectGroups = await _projectGroupRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && projectIds.Contains(x.ProjectId)).ToListAsync();
|
||
var eventGroups = await _groupRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && x.EventId == eventId && projectIds.Contains(x.ProjectId)).ToListAsync();
|
||
return new OrderBookProjectCatalog
|
||
{
|
||
EventId = eventId, Projects = projects, Rules = rules, EventProjects = eventProjects,
|
||
ProjectGroups = projectGroups, EventGroups = eventGroups
|
||
};
|
||
}
|
||
|
||
private async Task ValidateRefereesAsync(
|
||
List<OrderBookDraftReferee> referees, List<OrderBookParseIssue> issues)
|
||
{
|
||
var mobiles = referees.Select(x => x.Mobile).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList();
|
||
if (mobiles.Count == 0) return;
|
||
|
||
var registeredMobiles = await _refereeRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && x.AuditStatus == AuditStatus.Pass && mobiles.Contains(x.Mobile))
|
||
.Select(x => x.Mobile).ToListAsync();
|
||
foreach (var referee in referees.Where(x => !registeredMobiles.Contains(x.Mobile)))
|
||
issues.Add(RefereeIssue(referee.Row, "手机号", $"手机号【{referee.Mobile}】尚未完成裁判注册认证"));
|
||
}
|
||
|
||
private async Task ValidateAppendRulesAsync(List<OrderBookDraftEntry> entries, long eventId,
|
||
List<OrderBookParseIssue> issues)
|
||
{
|
||
var projectIds = entries.Where(x => x.EventProjectId > 0).Select(x => x.EventProjectId).Distinct().ToList();
|
||
var sessions = await _sessionRepository.AsQueryable()
|
||
.Where(x => !x.DeleteMark && x.EventId == eventId && x.SessionStatus != 90 && projectIds.Contains(x.EventProjectId))
|
||
.ToListAsync();
|
||
var rulesByProject = sessions.ToLookup(x => x.EventProjectId, x => x.ScoreRuleId);
|
||
foreach (var entry in entries.Where(x => x.EventProjectId > 0 && x.ScoreRuleId > 0))
|
||
{
|
||
if (rulesByProject[entry.EventProjectId].Any(x => x != entry.ScoreRuleId))
|
||
issues.Add(Issue(entry.Row, "计分规则", $"项目【{entry.ProjectName}】已有场次的规则与本次导入不一致，请先核查历史编排"));
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 确认落库
|
||
|
||
/// <summary>
|
||
/// 确认导入：按解析结果生成场地、场次、出场及裁判名单（幂等，同一批次只生成一次）
|
||
/// </summary>
|
||
/// <param name="input"></param>
|
||
/// <returns></returns>
|
||
[UnitOfWork]
|
||
[DisplayName("确认秩序册导入")]
|
||
[HttpPost("confirm")]
|
||
public async Task<OrderBookConfirmOutput> Confirm([FromBody] OrderBookConfirmInput input)
|
||
{
|
||
var cached = await _cache.GetAsync<OrderBookDraft>(BatchKey(input.BatchId));
|
||
if (!cached.HasValue || cached.Value == null)
|
||
throw Oops.Bah("导入批次不存在或已过期，请重新上传秩序册");
|
||
|
||
var draft = cached.Value;
|
||
|
||
var currentUserId = _authManager.UserId;
|
||
if (draft.CreatedUserId != currentUserId)
|
||
throw Oops.Bah("无权确认其他用户创建的导入批次");
|
||
if (draft.HasErrors)
|
||
throw Oops.Bah("导入文件仍存在校验错误，请修正后重新上传");
|
||
|
||
var confirmedCache = await _cache.GetAsync<bool>(ConfirmedKey(input.BatchId));
|
||
if (confirmedCache.HasValue && confirmedCache.Value)
|
||
throw Oops.Bah("该批次已确认，请勿重复提交");
|
||
|
||
if (!draft.Entries.Any())
|
||
throw Oops.Bah("秩序册没有可导入的出场数据");
|
||
if (!draft.EventId.HasValue || draft.EventId.Value <= 0)
|
||
throw Oops.Bah("请先创建赛事，再导入秩序册");
|
||
|
||
var eventId = draft.EventId.Value;
|
||
var eventInfo = await _eventRepository.GetFirstAsync(e => e.Id == eventId && !e.DeleteMark)
|
||
?? throw Oops.Bah("赛事不存在或已删除");
|
||
|
||
// 旧版本缓存没有真实关联ID，必须重新解析；不能在确认时重新选另一个同名项目。
|
||
var catalog = await LoadProjectCatalogAsync(draft.Entries, eventId);
|
||
var issues = ValidateProjects(draft.Entries, catalog, verifyResolvedIds: true);
|
||
if (draft.ImportMode == "append") await ValidateAppendRulesAsync(draft.Entries, eventId, issues);
|
||
await ValidateRefereesAsync(draft.Referees, issues);
|
||
if (issues.Any(x => x.Level == "error"))
|
||
throw Oops.Bah(string.Join("；", issues.Where(x => x.Level == "error")
|
||
.Take(10).Select(x => x.Row > 0 ? $"{x.Sheet}第{x.Row}行：{x.Message}" : x.Message)) + "。请重新上传并解析");
|
||
var projectContext = BuildProjectContext(draft, catalog);
|
||
var now = DateTime.Now;
|
||
|
||
// 所有配置复核通过后才覆盖旧编排；后续写入由工作单元统一回滚。
|
||
if (draft.ImportMode == "overwrite")
|
||
await SoftDeleteArrangementAsync(eventId);
|
||
|
||
// 2. 准备场地
|
||
var venueContext = await EnsureVenuesAsync(draft, eventId, currentUserId, now);
|
||
|
||
// 3. 生成场次
|
||
var sessionContext = await EnsureSessionsAsync(draft, eventId, projectContext, venueContext, currentUserId, now);
|
||
|
||
// 4. 生成出场
|
||
var entryCount = await CreateEntriesAsync(draft, projectContext, venueContext, sessionContext, currentUserId, now);
|
||
|
||
// 5. 裁判名单 + 可选打分账号
|
||
var refereeCount = await EnsureRefereesAsync(draft, eventId, input, currentUserId, now);
|
||
|
||
// 幂等标记 + 清理批次缓存
|
||
await _cache.SetAsync(ConfirmedKey(input.BatchId), true, BatchTtl);
|
||
await _cache.RemoveAsync(BatchKey(input.BatchId));
|
||
if (await _cache.GetAsync<long>(CurrentKey(eventId, currentUserId)) is { HasValue: true } current && current.Value == input.BatchId)
|
||
await _cache.RemoveAsync(CurrentKey(eventId, currentUserId));
|
||
|
||
return new OrderBookConfirmOutput
|
||
{
|
||
OrderBookVersion = 1,
|
||
VenueCount = venueContext.Count,
|
||
SessionCount = sessionContext.Count,
|
||
EntryCount = entryCount,
|
||
RefereeCount = refereeCount
|
||
};
|
||
}
|
||
|
||
private async Task SoftDeleteArrangementAsync(long eventId)
|
||
{
|
||
var sessionIds = await _sessionRepository.AsQueryable()
|
||
.Where(s => !s.DeleteMark && s.EventId == eventId)
|
||
.Select(s => s.Id).ToListAsync();
|
||
|
||
if (sessionIds.Any())
|
||
{
|
||
// 场次被覆盖后，原裁判席位不再对应新场次，必须重新分配。
|
||
await _judgeAssignmentRepository.SoftDeleteAsync(x => sessionIds.Contains(x.SessionId));
|
||
await _entryRepository.SoftDeleteAsync(e => sessionIds.Contains(e.SessionId));
|
||
await _sessionRepository.SoftDeleteAsync(s => sessionIds.Contains(s.Id));
|
||
}
|
||
await _venueRepository.SoftDeleteAsync(v => v.EventId == eventId);
|
||
}
|
||
|
||
// 仅使用解析并复核通过的真实ID，不再通过导入补建项目或组别。
|
||
private static Dictionary<long, OrderBookProjectContext> BuildProjectContext(
|
||
OrderBookDraft draft, OrderBookProjectCatalog catalog)
|
||
{
|
||
var projects = catalog.Projects.ToDictionary(x => x.Id);
|
||
return draft.Entries.GroupBy(x => x.EventProjectId).ToDictionary(x => x.Key, x =>
|
||
{
|
||
var entry = x.First();
|
||
return new OrderBookProjectContext
|
||
{
|
||
Project = projects[entry.ProjectId], EventProjectId = entry.EventProjectId,
|
||
ScoreRuleId = entry.ScoreRuleId
|
||
};
|
||
});
|
||
}
|
||
|
||
// 场地建档（追加模式按名称复用），返回场地名 -> 场地上下文 的映射
|
||
private async Task<Dictionary<string, OrderBookVenueContext>> EnsureVenuesAsync(
|
||
OrderBookDraft draft, long eventId, long userId, DateTime now)
|
||
{
|
||
var venueNames = draft.Entries.Select(e => e.VenueName).Where(n => !string.IsNullOrWhiteSpace(n)).Distinct().ToList();
|
||
var existVenues = await _venueRepository.AsQueryable()
|
||
.Where(v => !v.DeleteMark && v.EventId == eventId).OrderBy(v => v.Sort).ToListAsync();
|
||
|
||
var result = new Dictionary<string, OrderBookVenueContext>();
|
||
foreach (var name in venueNames)
|
||
{
|
||
var venue = existVenues.FirstOrDefault(v => v.VenueName == name);
|
||
int venueIndex;
|
||
if (venue == null)
|
||
{
|
||
venueIndex = existVenues.Count + 1;
|
||
venue = new EventVenue
|
||
{
|
||
Id = _idGenerator.NextId(),
|
||
EventId = eventId,
|
||
VenueCode = $"V{venueIndex:00}",
|
||
VenueName = name,
|
||
Sort = venueIndex,
|
||
Status = AvailabilityStatus.Enable,
|
||
CreatedUserId = userId,
|
||
CreatedTime = now
|
||
};
|
||
await _venueRepository.InsertAsync(venue);
|
||
existVenues.Add(venue);
|
||
}
|
||
else
|
||
{
|
||
venueIndex = venue.Sort <= 0 ? existVenues.IndexOf(venue) + 1 : venue.Sort;
|
||
}
|
||
result[name] = new OrderBookVenueContext { Venue = venue, Index = venueIndex };
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// 按 项目×组别×场地 生成场次，返回组合键 -> 场次 的映射
|
||
private async Task<Dictionary<OrderBookSessionKey, EventSession>> EnsureSessionsAsync(
|
||
OrderBookDraft draft, long eventId,
|
||
Dictionary<long, OrderBookProjectContext> projectContext,
|
||
Dictionary<string, OrderBookVenueContext> venueContext,
|
||
long userId, DateTime now)
|
||
{
|
||
var combos = draft.Entries
|
||
.Select(OrderBookSessionKey.From)
|
||
.Distinct()
|
||
.ToList();
|
||
|
||
var result = new Dictionary<OrderBookSessionKey, EventSession>();
|
||
var sessionSort = 0;
|
||
foreach (var combo in combos)
|
||
{
|
||
var pc = projectContext[combo.EventProjectId];
|
||
var vc = venueContext[combo.VenueName];
|
||
var groupId = combo.EventProjectGroupId;
|
||
|
||
var exist = await _sessionRepository.GetFirstAsync(s =>
|
||
!s.DeleteMark && s.EventId == eventId &&
|
||
s.EventProjectId == pc.EventProjectId && s.VenueId == vc.Venue.Id &&
|
||
s.SessionName == combo.SessionName &&
|
||
s.EventProjectGroupId == groupId);
|
||
if (exist != null)
|
||
{
|
||
if (exist.ScoreRuleId != pc.ScoreRuleId)
|
||
throw Oops.Bah($"场次【{combo.SessionName}】的规则与导入项目不一致，请先核查历史编排");
|
||
result[combo] = exist;
|
||
continue;
|
||
}
|
||
|
||
sessionSort++;
|
||
var session = new EventSession
|
||
{
|
||
Id = _idGenerator.NextId(),
|
||
EventId = eventId,
|
||
EventProjectId = pc.EventProjectId,
|
||
EventProjectGroupId = groupId,
|
||
VenueId = vc.Venue.Id,
|
||
ScoreRuleId = pc.ScoreRuleId,
|
||
SessionNo = $"EP{pc.EventProjectId}-V{vc.Index:00}-{sessionSort:000}",
|
||
SessionName = combo.SessionName,
|
||
SessionStatus = 0,
|
||
Version = 1,
|
||
Status = AvailabilityStatus.Enable,
|
||
CreatedUserId = userId,
|
||
CreatedTime = now
|
||
};
|
||
await _sessionRepository.InsertAsync(session);
|
||
result[combo] = session;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// 生成出场记录，返回数量
|
||
private async Task<int> CreateEntriesAsync(
|
||
OrderBookDraft draft,
|
||
Dictionary<long, OrderBookProjectContext> projectContext,
|
||
Dictionary<string, OrderBookVenueContext> venueContext,
|
||
Dictionary<OrderBookSessionKey, EventSession> sessionContext,
|
||
long userId, DateTime now)
|
||
{
|
||
// 统计每个场次已有的最大出场顺序，追加模式在此基础上递增
|
||
var sessionIds = sessionContext.Values.Select(s => s.Id).ToList();
|
||
var existOrders = await _entryRepository.AsQueryable()
|
||
.Where(e => !e.DeleteMark && sessionIds.Contains(e.SessionId))
|
||
.GroupBy(e => e.SessionId)
|
||
.Select(e => new { SessionId = e.SessionId, MaxOrder = SqlFunc.AggregateMax(e.PlayOrder) })
|
||
.ToListAsync();
|
||
var orderCounter = existOrders.ToDictionary(x => x.SessionId, x => x.MaxOrder);
|
||
var usedEntryNos = (await _entryRepository.AsQueryable()
|
||
.Where(e => !e.DeleteMark && sessionIds.Contains(e.SessionId))
|
||
.Select(e => new { e.SessionId, e.EntryNo }).ToListAsync())
|
||
.GroupBy(x => x.SessionId)
|
||
.ToDictionary(g => g.Key, g => g.Select(x => x.EntryNo).ToHashSet());
|
||
|
||
var toInsert = new List<EventSessionEntry>();
|
||
foreach (var d in draft.Entries)
|
||
{
|
||
var session = sessionContext[OrderBookSessionKey.From(d)];
|
||
var pc = projectContext[d.EventProjectId];
|
||
var vc = venueContext[d.VenueName];
|
||
|
||
orderCounter.TryGetValue(session.Id, out var order);
|
||
order++;
|
||
orderCounter[session.Id] = order;
|
||
|
||
var entryNo = $"{pc.Project.SortIndex:000}{vc.Index:00}{order:000}";
|
||
if (!usedEntryNos.TryGetValue(session.Id, out var noSet))
|
||
{
|
||
noSet = new HashSet<string>();
|
||
usedEntryNos[session.Id] = noSet;
|
||
}
|
||
// 自动编号撞号时追加顺序位，保证唯一
|
||
while (!noSet.Add(entryNo))
|
||
entryNo = $"{entryNo}-{order}";
|
||
|
||
toInsert.Add(new EventSessionEntry
|
||
{
|
||
Id = _idGenerator.NextId(),
|
||
SessionId = session.Id,
|
||
ParticipationRecordId = null,
|
||
RegistrationItemId = null,
|
||
SourceType = 1, // 秩序册导入
|
||
EntryNo = entryNo,
|
||
PlayOrder = order,
|
||
EntryStatus = 0,
|
||
IsRematch = false,
|
||
IsVoided = false,
|
||
ParticipantName = d.ParticipantName,
|
||
TeamName = d.TeamName,
|
||
GroupName = d.GroupName,
|
||
Version = 1,
|
||
Status = AvailabilityStatus.Enable,
|
||
CreatedUserId = userId,
|
||
CreatedTime = now
|
||
});
|
||
}
|
||
|
||
if (toInsert.Any())
|
||
await _entryRepository.InsertRangeAsync(toInsert);
|
||
return toInsert.Count;
|
||
}
|
||
|
||
// 裁判档案 / 赛事裁判关系 / 可选打分账号，返回纳入的裁判数量
|
||
private async Task<int> EnsureRefereesAsync(
|
||
OrderBookDraft draft, long eventId, OrderBookConfirmInput input, long userId, DateTime now)
|
||
{
|
||
if (!draft.Referees.Any())
|
||
return 0;
|
||
|
||
string? password = null;
|
||
if (input.GenerateJudgeAccount)
|
||
{
|
||
password = input.DefaultPassword?.Trim();
|
||
if (string.IsNullOrWhiteSpace(password))
|
||
throw Oops.Bah("生成裁判账号时必须设置初始密码");
|
||
if (password.Length is < 6 or > 32)
|
||
throw Oops.Bah("裁判初始密码长度必须为6-32位");
|
||
}
|
||
|
||
var mobiles = draft.Referees.Select(r => r.Mobile).Distinct().ToList();
|
||
var existReferees = await _refereeRepository.AsQueryable()
|
||
.Where(r => !r.DeleteMark && r.AuditStatus == AuditStatus.Pass && mobiles.Contains(r.Mobile))
|
||
.ToListAsync();
|
||
var existEventReferees = await _eventRefereeRepository.AsQueryable()
|
||
.Where(er => !er.DeleteMark && er.EventId == eventId).ToListAsync();
|
||
var existAppUsers = await _appUserRepository.AsQueryable().Where(u => !u.DeleteMark && mobiles.Contains(u.Mobile)).ToListAsync();
|
||
|
||
var newEventReferees = new List<EventReferee>();
|
||
var count = 0;
|
||
foreach (var d in draft.Referees)
|
||
{
|
||
var referee = existReferees.FirstOrDefault(r => r.Mobile == d.Mobile);
|
||
if (referee == null)
|
||
throw Oops.Bah($"裁判【{d.Name}】尚未完成注册认证，请重新上传秩序册");
|
||
|
||
if (input.GenerateJudgeAccount)
|
||
{
|
||
var appUser = existAppUsers.FirstOrDefault(u => u.Mobile == d.Mobile);
|
||
if (appUser == null)
|
||
{
|
||
var appUserId = _idGenerator.NextId();
|
||
appUser = new Core.Entities.AppUser
|
||
{
|
||
Id = appUserId,
|
||
PersonType = PersonType.User,
|
||
MiniProgramRole = MiniProgramRole.Referee,
|
||
Name = d.Name,
|
||
Mobile = d.Mobile,
|
||
Gender = Gender.Unknown,
|
||
Password = MD5Encryption.Encrypt($"{_idGenerator.Encode(appUserId)}{password!}"),
|
||
AuditStatus = AuditStatus.Pass,
|
||
AuditUserId = userId,
|
||
AuditTime = now,
|
||
Status = AvailabilityStatus.Enable,
|
||
CreatedUserId = userId,
|
||
CreatedTime = now
|
||
};
|
||
await _appUserRepository.InsertAsync(appUser);
|
||
existAppUsers.Add(appUser);
|
||
|
||
referee.AppUserId = appUser.Id;
|
||
referee.UpdatedUserId = userId;
|
||
referee.UpdatedTime = now;
|
||
await _refereeRepository.UpdateAsync(referee);
|
||
}
|
||
else if (referee.AppUserId == null)
|
||
{
|
||
referee.AppUserId = appUser.Id;
|
||
referee.UpdatedUserId = userId;
|
||
referee.UpdatedTime = now;
|
||
await _refereeRepository.UpdateAsync(referee);
|
||
}
|
||
}
|
||
|
||
if (existEventReferees.All(er => er.RefereeId != referee.Id))
|
||
{
|
||
newEventReferees.Add(new EventReferee
|
||
{
|
||
Id = _idGenerator.NextId(),
|
||
EventId = eventId,
|
||
RefereeId = referee.Id,
|
||
RefereeApplicationId = null,
|
||
SourceType = 3, // 秩序册导入
|
||
Status = AvailabilityStatus.Enable,
|
||
CreatedUserId = userId,
|
||
CreatedTime = now
|
||
});
|
||
}
|
||
count++;
|
||
}
|
||
|
||
if (newEventReferees.Any())
|
||
await _eventRefereeRepository.InsertRangeAsync(newEventReferees);
|
||
return count;
|
||
}
|
||
|
||
#endregion
|
||
|
||
private static List<OrderBookParseIssue> ValidateProjects(
|
||
IReadOnlyList<OrderBookDraftEntry> entries, OrderBookProjectCatalog catalog,
|
||
bool verifyResolvedIds = false)
|
||
{
|
||
static string Normalize(string? value) => value?.Trim() ?? string.Empty;
|
||
|
||
var issues = new List<OrderBookParseIssue>();
|
||
var projectsByName = catalog.Projects.Where(x => !x.DeleteMark)
|
||
.ToLookup(x => Normalize(x.Name), StringComparer.Ordinal);
|
||
var rulesByName = catalog.Rules.Where(x => !x.DeleteMark && x.Status == AvailabilityStatus.Enable)
|
||
.ToLookup(x => Normalize(x.RuleName), StringComparer.Ordinal);
|
||
var eventProjectsByProject = catalog.EventProjects
|
||
.Where(x => !x.DeleteMark && x.EventId == catalog.EventId).ToLookup(x => x.ProjectId);
|
||
var baseGroups = catalog.ProjectGroups.Where(x => !x.DeleteMark).ToDictionary(x => x.Id);
|
||
var eventGroupsByProject = catalog.EventGroups
|
||
.Where(x => !x.DeleteMark && x.EventId == catalog.EventId).ToLookup(x => x.EventProjectId);
|
||
|
||
foreach (var entry in entries)
|
||
{
|
||
var projectName = Normalize(entry.ProjectName);
|
||
var ruleName = Normalize(entry.ScoreRuleName);
|
||
var groupName = Normalize(entry.GroupName);
|
||
// 必填错误由行解析返回，避免重复提示。
|
||
if (projectName.Length == 0 || ruleName.Length == 0 || groupName.Length == 0) continue;
|
||
|
||
void AddError(string column, string message) => issues.Add(new OrderBookParseIssue
|
||
{
|
||
Row = entry.Row, Column = column, Message = message, Level = "error"
|
||
});
|
||
|
||
var rules = rulesByName[ruleName].ToList();
|
||
if (rules.Count != 1)
|
||
{
|
||
AddError("计分规则", rules.Count == 0
|
||
? $"计分规则【{ruleName}】不存在或已停用，请先维护或从最新版模板选择"
|
||
: $"计分规则【{ruleName}】存在多条同名配置，无法唯一匹配，请先整理平台配置");
|
||
continue;
|
||
}
|
||
|
||
var rule = rules[0];
|
||
var namedProjects = projectsByName[projectName].Where(x => x.Status == AvailabilityStatus.Enable).ToList();
|
||
var matchedProjects = namedProjects.Where(x => x.ScoreRuleId == rule.Id).ToList();
|
||
var candidates = matchedProjects.SelectMany(project => eventProjectsByProject[project.Id]
|
||
.Select(eventProject => (Project: project, EventProject: eventProject))).ToList();
|
||
if (candidates.Count != 1)
|
||
{
|
||
var message = candidates.Count > 1
|
||
? $"当前赛事的项目【{projectName}】＋计分规则【{ruleName}】匹配到多条记录，请先整理重复的项目配置"
|
||
: namedProjects.Count == 0
|
||
? $"项目【{projectName}】不存在或已停用，请先维护平台项目并加入当前赛事"
|
||
: matchedProjects.Count == 0
|
||
? $"项目【{projectName}】没有配置计分规则【{ruleName}】，请统一平台配置与秩序册"
|
||
: $"项目【{projectName}】＋计分规则【{ruleName}】尚未加入当前赛事，请先在赛事中配置";
|
||
AddError("项目名称", message);
|
||
continue;
|
||
}
|
||
|
||
var (project, eventProject) = candidates[0];
|
||
var projectEventGroups = eventGroupsByProject[eventProject.Id].ToList();
|
||
var groups = projectEventGroups.Where(x => Normalize(x.GroupName) == groupName).ToList();
|
||
if (groups.Count != 1)
|
||
{
|
||
AddError("组别名称", groups.Count == 0
|
||
? $"项目【{projectName}】＋计分规则【{ruleName}】未配置赛事组别【{groupName}】，请先维护并加入当前赛事"
|
||
: $"项目【{projectName}】＋计分规则【{ruleName}】存在重复赛事组别【{groupName}】，无法唯一匹配");
|
||
continue;
|
||
}
|
||
|
||
var group = groups[0];
|
||
if (group.ProjectGroupId <= 0 || group.ProjectId != project.Id ||
|
||
!baseGroups.TryGetValue(group.ProjectGroupId, out var baseGroup) ||
|
||
baseGroup.ProjectId != project.Id || Normalize(baseGroup.GroupName) != groupName ||
|
||
projectEventGroups.Count(x => x.ProjectGroupId == group.ProjectGroupId) != 1)
|
||
{
|
||
AddError("组别名称", $"项目【{projectName}】＋计分规则【{ruleName}】的组别【{groupName}】关联无效或重复，请先修复平台及赛事组别配置");
|
||
continue;
|
||
}
|
||
|
||
if (verifyResolvedIds && (entry.ProjectId != project.Id || entry.EventProjectId != eventProject.Id ||
|
||
entry.ScoreRuleId != rule.Id || entry.ProjectGroupId != baseGroup.Id || entry.EventProjectGroupId != group.Id))
|
||
{
|
||
AddError("项目名称", $"项目【{projectName}】的项目、组别或规则配置已变化，请重新上传并解析秩序册");
|
||
continue;
|
||
}
|
||
|
||
entry.ProjectId = project.Id;
|
||
entry.EventProjectId = eventProject.Id;
|
||
entry.ScoreRuleId = rule.Id;
|
||
entry.ProjectGroupId = baseGroup.Id;
|
||
entry.EventProjectGroupId = group.Id;
|
||
}
|
||
return issues;
|
||
}
|
||
|
||
#region 辅助
|
||
|
||
private static string BatchKey(long batchId) => $"orderbook:batch:{batchId}";
|
||
private static string CurrentKey(long eventId, long userId) => $"orderbook:current:{eventId}:{userId}";
|
||
private static string ConfirmedKey(long batchId) => $"orderbook:confirmed:{batchId}";
|
||
|
||
private static OrderBookParseIssue Issue(int row, string column, string message, string level = "error")
|
||
=> new() { Row = row, Column = column, Message = message, Level = level };
|
||
|
||
private static OrderBookParseIssue RefereeIssue(int row, string column, string message, string level = "error")
|
||
=> new() { Sheet = RefereeSheetName, Row = row, Column = column, Message = message, Level = level };
|
||
|
||
private static string? Trim(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
|
||
|
||
private static bool IsAllBlank(params string?[] values) => values.All(string.IsNullOrWhiteSpace);
|
||
|
||
/// <summary>导入匹配只读取已维护的配置，不创建或修复业务数据。</summary>
|
||
private sealed class OrderBookProjectCatalog
|
||
{
|
||
public long EventId { get; init; }
|
||
public List<Core.Entities.Project> Projects { get; init; } = new();
|
||
public List<Core.Entities.ScoreRule> Rules { get; init; } = new();
|
||
public List<EventProject> EventProjects { get; init; } = new();
|
||
public List<ProjectGroup> ProjectGroups { get; init; } = new();
|
||
public List<EventProjectGroup> EventGroups { get; init; } = new();
|
||
}
|
||
|
||
/// <summary>用真实赛事项目、组别ID区分同名项目；结构化键避免名称含分隔符时碰撞。</summary>
|
||
private readonly record struct OrderBookSessionKey(long EventProjectId, long EventProjectGroupId, string SessionName, string VenueName)
|
||
{
|
||
public static OrderBookSessionKey From(OrderBookDraftEntry entry) =>
|
||
new(entry.EventProjectId, entry.EventProjectGroupId, entry.SessionName, entry.VenueName);
|
||
}
|
||
|
||
private sealed class OrderBookProjectContext
|
||
{
|
||
public Core.Entities.Project Project { get; set; } = null!;
|
||
public long EventProjectId { get; set; }
|
||
public long ScoreRuleId { get; set; }
|
||
}
|
||
|
||
private sealed class OrderBookVenueContext
|
||
{
|
||
public EventVenue Venue { get; set; } = null!;
|
||
public int Index { get; set; }
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// 秩序册导入模板导出器：出场秩序 + 裁判名单 + 计分规则参考
|
||
/// </summary>
|
||
internal sealed class OrderBookTemplateExporter : ExcelExportBase
|
||
{
|
||
private const int EntryInputEndRow = 1000;
|
||
private readonly IReadOnlyList<string> _scoreRuleNames;
|
||
|
||
public OrderBookTemplateExporter(IReadOnlyList<string> scoreRuleNames)
|
||
{
|
||
_scoreRuleNames = scoreRuleNames;
|
||
}
|
||
|
||
public override Task<byte[]> ExportAsync()
|
||
{
|
||
var headerColor = Color.FromArgb(217, 225, 242);
|
||
|
||
#region 出场秩序
|
||
CreateWorksheet("出场秩序");
|
||
var entryHeaders = new[] { "项目名称*", "计分规则*", "组别名称*", "姓名*", "队伍名称", "单位", "场次*", "场地*" };
|
||
SetMergeTitle("秩序册 - 出场秩序（带*为必填；计分规则请从下拉列表选择）", 1, 1, 1, entryHeaders.Length, headerColor, 12);
|
||
SetHeaders(entryHeaders, 2, headerColor);
|
||
SetDataRowStyle(3, entryHeaders.Length);
|
||
var scoreRuleValidation = Worksheet.DataValidations.AddListValidation($"B3:B{EntryInputEndRow}");
|
||
scoreRuleValidation.Formula.ExcelFormula = $"'计分规则参考'!$B$3:$B${_scoreRuleNames.Count + 2}";
|
||
scoreRuleValidation.AllowBlank = false;
|
||
scoreRuleValidation.ShowInputMessage = true;
|
||
scoreRuleValidation.PromptTitle = "请选择计分规则";
|
||
scoreRuleValidation.Prompt = "下拉列表来自当前已启用的计分规则。";
|
||
scoreRuleValidation.ShowErrorMessage = true;
|
||
scoreRuleValidation.ErrorTitle = "计分规则无效";
|
||
scoreRuleValidation.Error = "请选择下拉列表中的计分规则。";
|
||
SetColumnWidths(new double[] { 18, 22, 14, 22, 18, 22, 22, 16 });
|
||
FreezePanes(3, 1);
|
||
#endregion
|
||
|
||
#region 裁判名单
|
||
CreateWorksheet("裁判名单");
|
||
var refereeHeaders = new[] { "序号", "姓名*", "手机号*" };
|
||
SetMergeTitle("秩序册 - 裁判名单（须完成注册认证；无裁判可留空）", 1, 1, 1, refereeHeaders.Length, headerColor, 12);
|
||
SetHeaders(refereeHeaders, 2, headerColor);
|
||
SetDataRowStyle(3, refereeHeaders.Length);
|
||
SetColumnWidths(new double[] { 10, 18, 22 });
|
||
FreezePanes(3, 1);
|
||
#endregion
|
||
|
||
#region 计分规则参考
|
||
CreateWorksheet("计分规则参考");
|
||
var scoreRuleHeaders = new[] { "序号", "计分规则名称" };
|
||
SetMergeTitle("当前已启用的计分规则", 1, 1, 1, scoreRuleHeaders.Length, headerColor, 12);
|
||
SetHeaders(scoreRuleHeaders, 2, headerColor);
|
||
for (var i = 0; i < _scoreRuleNames.Count; i++)
|
||
{
|
||
Worksheet.Cells[i + 3, 1].Value = i + 1;
|
||
Worksheet.Cells[i + 3, 2].Value = _scoreRuleNames[i];
|
||
SetDataRowStyle(i + 3, scoreRuleHeaders.Length);
|
||
}
|
||
SetColumnWidths(new double[] { 8, 36 });
|
||
FreezePanes(3, 1);
|
||
#endregion
|
||
|
||
return GetAsByteArrayAsync();
|
||
}
|
||
}
|