340 lines
15 KiB
C#
340 lines
15 KiB
C#
using System.Text.Json;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Tiku.Application.Assets;
|
|
using Tiku.Application.Catalog;
|
|
using Tiku.Application.Content;
|
|
using Tiku.Domain.Catalog;
|
|
using Tiku.Domain.Common;
|
|
using Tiku.Domain.Content;
|
|
using Tiku.Domain.Learning;
|
|
using Tiku.Domain.Operations;
|
|
using Tiku.Domain.QuestionBanks;
|
|
|
|
namespace Tiku.Infrastructure.Content;
|
|
|
|
internal sealed class ContentImportService(
|
|
DirectContentServiceDependencies dependencies,
|
|
IQuestionManagementService questionService,
|
|
IVocabularyManagementService vocabularyService,
|
|
IHandbookManagementService handbookService,
|
|
IScorelineManagementService scorelineService,
|
|
IVideoManagementService videoService)
|
|
: DirectContentServiceBase(dependencies), IContentImportService
|
|
{
|
|
public Task<SimpleImportResult> PreviewImportAsync(
|
|
DirectContentActor actor,
|
|
SimpleImportCommand command,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
return CreateImportJobAsync(actor, command with { DryRun = true }, false, cancellationToken);
|
|
}
|
|
|
|
public Task<SimpleImportResult> ExecuteImportAsync(
|
|
DirectContentActor actor,
|
|
SimpleImportCommand command,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
return CreateImportJobAsync(actor, command with { DryRun = false }, true, cancellationToken);
|
|
}
|
|
|
|
public async Task<ContentImportJobDetail> GetImportJobAsync(
|
|
DirectContentActor actor,
|
|
Guid jobId,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var job = await questionBankPersistence.ContentImportJobs.AsNoTracking()
|
|
.Where(item => item.TenantId == actor.TenantId && item.Id == jobId)
|
|
.Select(item => ToJobItem(item))
|
|
.SingleOrDefaultAsync(cancellationToken);
|
|
if (job is null) throw new ContentManagementException("Import job was not found.", "import_job_not_found");
|
|
|
|
var items = await questionBankPersistence.ContentImportItems.AsNoTracking()
|
|
.Where(item => item.TenantId == actor.TenantId && item.JobId == jobId)
|
|
.OrderBy(item => item.RowNo)
|
|
.Take(MaxLimit)
|
|
.Select(item => ToImportItem(item))
|
|
.ToArrayAsync(cancellationToken);
|
|
var issues = await questionBankPersistence.ContentImportIssues.AsNoTracking()
|
|
.Where(issue => issue.TenantId == actor.TenantId && issue.JobId == jobId)
|
|
.OrderBy(issue => issue.RowNo)
|
|
.ThenBy(issue => issue.CreatedAt)
|
|
.Take(MaxLimit)
|
|
.Select(issue => new ContentImportIssueModel(
|
|
issue.Id,
|
|
issue.JobId,
|
|
issue.ItemId,
|
|
issue.RowNo,
|
|
issue.Severity,
|
|
issue.Code,
|
|
issue.FieldPath,
|
|
issue.Message,
|
|
issue.Details))
|
|
.ToArrayAsync(cancellationToken);
|
|
|
|
return new ContentImportJobDetail(job, items, issues);
|
|
}
|
|
|
|
public async Task<CatalogList<ContentImportIssueModel>> GetImportIssuesAsync(
|
|
DirectContentActor actor,
|
|
Guid jobId,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertImportJobAsync(actor.TenantId, jobId, cancellationToken);
|
|
var issues = await questionBankPersistence.ContentImportIssues.AsNoTracking()
|
|
.Where(item => item.TenantId == actor.TenantId && item.JobId == jobId)
|
|
.OrderBy(item => item.RowNo)
|
|
.ThenBy(item => item.CreatedAt)
|
|
.Take(MaxLimit)
|
|
.Select(item => new ContentImportIssueModel(
|
|
item.Id,
|
|
item.JobId,
|
|
item.ItemId,
|
|
item.RowNo,
|
|
item.Severity,
|
|
item.Code,
|
|
item.FieldPath,
|
|
item.Message,
|
|
item.Details))
|
|
.ToArrayAsync(cancellationToken);
|
|
return new CatalogList<ContentImportIssueModel>(issues);
|
|
}
|
|
|
|
public async Task<ImportPostCheckResult> RunImportPostCheckAsync(
|
|
DirectContentActor actor,
|
|
Guid jobId,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var job = await questionBankPersistence.ContentImportJobs.SingleOrDefaultAsync(
|
|
item => item.TenantId == actor.TenantId && item.Id == jobId,
|
|
cancellationToken);
|
|
if (job is null) throw new ContentManagementException("Import job was not found.", "import_job_not_found");
|
|
|
|
var counts = JsonSerializer.SerializeToElement(new
|
|
{
|
|
job.TotalCount,
|
|
job.ValidCount,
|
|
job.ErrorCount,
|
|
job.WarningCount,
|
|
job.InsertedCount,
|
|
job.UpdatedCount,
|
|
job.SkippedCount
|
|
});
|
|
job.Summary = JsonSerializer.SerializeToElement(new
|
|
{
|
|
postCheck = new
|
|
{
|
|
status = job.ErrorCount == 0 ? "passed" : "warning",
|
|
checkedAt = DateTimeOffset.UtcNow,
|
|
counts
|
|
}
|
|
});
|
|
await unitOfWork.SaveChangesAsync(cancellationToken);
|
|
return new ImportPostCheckResult(job.Id, job.ErrorCount == 0 ? "passed" : "warning", counts, []);
|
|
}
|
|
|
|
public async Task<ImportPostCheckResult> GetImportPostCheckAsync(
|
|
DirectContentActor actor,
|
|
Guid jobId,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var job = await questionBankPersistence.ContentImportJobs.AsNoTracking().SingleOrDefaultAsync(
|
|
item => item.TenantId == actor.TenantId && item.Id == jobId,
|
|
cancellationToken);
|
|
if (job is null) throw new ContentManagementException("Import job was not found.", "import_job_not_found");
|
|
|
|
var issues = await GetImportIssuesAsync(actor, jobId, cancellationToken);
|
|
var counts = JsonSerializer.SerializeToElement(new
|
|
{
|
|
job.TotalCount,
|
|
job.ValidCount,
|
|
job.ErrorCount,
|
|
job.WarningCount,
|
|
job.InsertedCount,
|
|
job.UpdatedCount,
|
|
job.SkippedCount
|
|
});
|
|
return new ImportPostCheckResult(job.Id, job.ErrorCount == 0 ? "passed" : "warning", counts, issues.Items);
|
|
}
|
|
private async Task<SimpleImportResult> CreateImportJobAsync(
|
|
DirectContentActor actor,
|
|
SimpleImportCommand command,
|
|
bool execute,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!SupportedImportTypes.Contains(command.ImportType))
|
|
throw new ContentManagementException("Import type is invalid.", "import_type_invalid");
|
|
|
|
var importType = ParseImportType(command.ImportType);
|
|
var sourceFormat = Parse(command.SourceFormat, ImportSourceFormat.Json, "import_source_format_invalid");
|
|
var items = command.Items
|
|
.Select(item => item.ValueKind == JsonValueKind.Undefined ? JsonDefaults.Object() : item).ToArray();
|
|
var job = new ContentImportJob
|
|
{
|
|
TenantId = actor.TenantId,
|
|
CreatedBy = actor.UserId,
|
|
TargetRegionId = command.RegionId,
|
|
TargetSubjectId = command.SubjectId,
|
|
TargetCategoryId = command.CategoryId,
|
|
TargetContentNodeId = command.ContentNodeId,
|
|
TargetQuestionBankId = command.QuestionBankId,
|
|
ImportType = importType,
|
|
SourceFormat = sourceFormat,
|
|
Status = execute ? ContentImportStatus.Completed : ContentImportStatus.Preview,
|
|
SourceName = Normalize(command.SourceName),
|
|
DryRun = command.DryRun,
|
|
TotalCount = items.Length,
|
|
ValidCount = items.Length,
|
|
RawPayload = JsonSerializer.SerializeToElement(items),
|
|
NormalizedPayload = JsonSerializer.SerializeToElement(items),
|
|
StartedAt = execute ? DateTimeOffset.UtcNow : null,
|
|
FinishedAt = execute ? DateTimeOffset.UtcNow : null
|
|
};
|
|
questionBankPersistence.ContentImportJobs.Add(job);
|
|
|
|
var importItems = new List<ContentImportItem>();
|
|
var rowNo = 1;
|
|
foreach (var payload in items)
|
|
{
|
|
var importItem = new ContentImportItem
|
|
{
|
|
TenantId = actor.TenantId,
|
|
JobId = job.Id,
|
|
RowNo = rowNo++,
|
|
ExternalId = GetString(payload, "legacyId") ?? GetString(payload, "id"),
|
|
Status = execute ? ContentImportItemStatus.Inserted : ContentImportItemStatus.Valid,
|
|
SourcePayload = payload,
|
|
NormalizedPayload = payload
|
|
};
|
|
|
|
if (execute)
|
|
{
|
|
var target = await WriteImportedItemAsync(actor, command, payload, cancellationToken);
|
|
importItem.TargetType = target.TargetType;
|
|
importItem.TargetId = target.TargetId;
|
|
job.InsertedCount++;
|
|
}
|
|
|
|
importItems.Add(importItem);
|
|
}
|
|
|
|
questionBankPersistence.ContentImportItems.AddRange(importItems);
|
|
job.Summary = JsonSerializer.SerializeToElement(new
|
|
{
|
|
mode = execute ? "execute" : "preview",
|
|
supportedTypes = SupportedImportTypes,
|
|
note = "Synchronous direct migration import skeleton; async worker will be introduced later."
|
|
});
|
|
|
|
await unitOfWork.SaveChangesAsync(cancellationToken);
|
|
return new SimpleImportResult(
|
|
ToJobItem(job),
|
|
importItems.Select(ToImportItem).ToArray(),
|
|
[]);
|
|
}
|
|
|
|
private async Task<(string TargetType, Guid TargetId)> WriteImportedItemAsync(
|
|
DirectContentActor actor,
|
|
SimpleImportCommand command,
|
|
JsonElement payload,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
switch (command.ImportType.ToLowerInvariant())
|
|
{
|
|
case "questions":
|
|
var result = await questionService.CreateQuestionAsync(actor, new QuestionWriteCommand(
|
|
null,
|
|
command.QuestionBankId,
|
|
command.SubjectId,
|
|
command.CategoryId,
|
|
null,
|
|
command.EntryId,
|
|
command.ContentNodeId,
|
|
command.CollectionId,
|
|
GetString(payload, "legacyId"),
|
|
GetString(payload, "type") ?? "choice",
|
|
GetString(payload, "typeLabel"),
|
|
GetInt(payload, "difficulty"),
|
|
GetElement(payload, "tags", JsonDefaults.Array()),
|
|
GetString(payload, "content") ?? GetString(payload, "title"),
|
|
GetElement(payload, "options", JsonDefaults.Array()),
|
|
GetInt(payload, "correctOptionIndex"),
|
|
GetElement(payload, "correctOptionIndices", JsonDefaults.Array()),
|
|
GetString(payload, "answerText") ?? GetString(payload, "answer"),
|
|
GetString(payload, "explanation"),
|
|
GetElement(payload, "subQuestions", JsonDefaults.Array()),
|
|
GetString(payload, "codeLang"),
|
|
GetString(payload, "codeTemplate"),
|
|
GetString(payload, "mediaUrl"),
|
|
"Published",
|
|
GetElement(payload, "examMarkers", JsonDefaults.Object()),
|
|
GetString(payload, "sourceHash"),
|
|
true), cancellationToken);
|
|
return ("question", result.Item.Id);
|
|
case "vocabulary":
|
|
var word = await vocabularyService.UpsertVocabularyWordAsync(actor, new VocabularyWordCommand(
|
|
null,
|
|
null,
|
|
command.EntryId,
|
|
command.ContentNodeId,
|
|
GetString(payload, "legacyId"),
|
|
GetString(payload, "word") ?? GetString(payload, "name") ?? "未命名单词",
|
|
GetString(payload, "phonetic"),
|
|
GetString(payload, "meaning"),
|
|
GetString(payload, "example"),
|
|
GetString(payload, "exampleTranslation"),
|
|
GetInt(payload, "difficulty"),
|
|
GetElement(payload, "tags", JsonDefaults.Array()),
|
|
GetInt(payload, "order"),
|
|
true,
|
|
GetElement(payload, "metadata", JsonDefaults.Object())), cancellationToken);
|
|
return ("vocabulary_word", word.Item.Id);
|
|
case "handbook":
|
|
var entry = await handbookService.UpsertHandbookEntryAsync(actor, new HandbookEntryCommand(
|
|
null,
|
|
null,
|
|
command.EntryId,
|
|
command.ContentNodeId,
|
|
GetString(payload, "legacyId"),
|
|
GetString(payload, "title") ?? GetString(payload, "name") ?? "未命名条目",
|
|
GetString(payload, "summary"),
|
|
GetString(payload, "content"),
|
|
GetElement(payload, "tags", JsonDefaults.Array()),
|
|
GetInt(payload, "order"),
|
|
true,
|
|
GetElement(payload, "metadata", JsonDefaults.Object())), cancellationToken);
|
|
return ("handbook_entry", entry.Item.Id);
|
|
case "scoreline":
|
|
var scoreline = await scorelineService.UpsertScorelineRecordAsync(actor, new ScorelineRecordCommand(
|
|
null,
|
|
command.RegionId,
|
|
GetGuid(payload, "schoolId"),
|
|
GetGuid(payload, "majorId"),
|
|
GetString(payload, "legacyId"),
|
|
GetInt(payload, "year") ?? DateTimeOffset.UtcNow.Year,
|
|
GetString(payload, "schoolName"),
|
|
GetString(payload, "majorName"),
|
|
GetElement(payload, "fieldValues", payload)), cancellationToken);
|
|
return ("scoreline_record", scoreline.Item.Id);
|
|
case "videos":
|
|
var video = await videoService.UpsertVideoAsync(actor, new VideoExplanationCommand(
|
|
null,
|
|
command.SubjectId,
|
|
GetString(payload, "legacyId"),
|
|
GetString(payload, "title") ?? "未命名视频",
|
|
GetString(payload, "description"),
|
|
GetString(payload, "videoUrl") ?? GetString(payload, "url"),
|
|
GetString(payload, "thumbnailUrl"),
|
|
GetInt(payload, "durationSeconds"),
|
|
GetElement(payload, "knowledgeTags", JsonDefaults.Array()),
|
|
GetBool(payload, "isGeneral"),
|
|
GetInt(payload, "difficulty"),
|
|
GetInt(payload, "order"),
|
|
true,
|
|
GetElement(payload, "metadata", JsonDefaults.Object())), cancellationToken);
|
|
return ("video_explanation", video.Item.Id);
|
|
default:
|
|
throw new ContentManagementException("Import type is invalid.", "import_type_invalid");
|
|
}
|
|
}
|
|
}
|