448 lines
18 KiB
C#
448 lines
18 KiB
C#
using System.Text.Json;
|
|
using PlotLine.Data;
|
|
using PlotLine.Models;
|
|
using PlotLine.ViewModels;
|
|
|
|
namespace PlotLine.Services;
|
|
|
|
public interface IStoryIntelligenceImportCommitService
|
|
{
|
|
Task<StoryIntelligenceImportConfirmationViewModel?> BuildConfirmationAsync(int runId);
|
|
Task<StoryIntelligenceImportCommitResult> CommitAsync(int runId, int userId);
|
|
}
|
|
|
|
public sealed class StoryIntelligenceImportCommitService(
|
|
IStoryIntelligenceResultRepository storyRuns,
|
|
IProjectRepository projects,
|
|
IBookRepository books,
|
|
IChapterRepository chapters,
|
|
ILookupRepository lookups,
|
|
ISceneMetricTypeRepository metricTypes,
|
|
IWriterWorkspaceRepository writerWorkspace,
|
|
ICharacterRepository characters,
|
|
ILogger<StoryIntelligenceImportCommitService> logger) : IStoryIntelligenceImportCommitService
|
|
{
|
|
private static readonly JsonSerializerOptions JsonOptions = new()
|
|
{
|
|
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
|
PropertyNameCaseInsensitive = true
|
|
};
|
|
|
|
private static readonly IReadOnlyDictionary<string, string[]> MetricAliases = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
["action"] = ["Action"],
|
|
["emotion"] = ["Emotion", "Emotional Weight", "Emotional Resonance"],
|
|
["tension"] = ["Tension"],
|
|
["conflict"] = ["Conflict", "Relationship Conflict"],
|
|
["mystery"] = ["Mystery"],
|
|
["romance"] = ["Romance", "Emotional Intimacy"],
|
|
["humour"] = ["Humour", "Humor", "Comedy", "Comic Relief"],
|
|
["revelation"] = ["Revelation", "Reveal"],
|
|
["pacingIntensity"] = ["PacingIntensity", "Pacing Intensity", "Overall Intensity"]
|
|
};
|
|
|
|
public async Task<StoryIntelligenceImportConfirmationViewModel?> BuildConfirmationAsync(int runId)
|
|
{
|
|
var prepared = await PrepareAsync(runId);
|
|
if (prepared is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return prepared.Confirmation;
|
|
}
|
|
|
|
public async Task<StoryIntelligenceImportCommitResult> CommitAsync(int runId, int userId)
|
|
{
|
|
var prepared = await PrepareAsync(runId);
|
|
if (prepared is null)
|
|
{
|
|
return new StoryIntelligenceImportCommitResult { Success = false, Message = "This Story Intelligence run could not be found." };
|
|
}
|
|
|
|
if (!prepared.Confirmation.CanCommit)
|
|
{
|
|
return new StoryIntelligenceImportCommitResult
|
|
{
|
|
Success = false,
|
|
Message = prepared.Confirmation.HasCompletedCommit
|
|
? "This Story Intelligence run has already been committed."
|
|
: string.Join(" ", prepared.Confirmation.Blockers)
|
|
};
|
|
}
|
|
|
|
var result = await storyRuns.CommitImportAsync(new StoryIntelligenceImportCommitRequest
|
|
{
|
|
StoryIntelligenceRunID = prepared.Run.StoryIntelligenceRunID,
|
|
UserID = userId,
|
|
ProjectID = prepared.Run.ProjectID!.Value,
|
|
BookID = prepared.Run.BookID!.Value,
|
|
ChapterID = prepared.Run.ChapterID!.Value,
|
|
TimeModeID = prepared.TimeModeID,
|
|
TimeConfidenceID = prepared.TimeConfidenceID,
|
|
RevisionStatusID = prepared.RevisionStatusID,
|
|
TimelineNoteTypeID = prepared.TimelineNoteTypeID,
|
|
Scenes = prepared.Scenes,
|
|
Warnings = prepared.Confirmation.Warnings
|
|
});
|
|
|
|
logger.LogInformation(
|
|
"Committed Story Intelligence run {StoryIntelligenceRunID}. CommitID={CommitID} ScenesCreated={ScenesCreated} MetricsCreated={MetricsCreated}",
|
|
runId,
|
|
result.CommitID,
|
|
result.ScenesCreated,
|
|
result.MetricsCreated);
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task<PreparedImport?> PrepareAsync(int runId)
|
|
{
|
|
var run = await storyRuns.GetRunAsync(runId);
|
|
if (run is null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var existingCommit = await storyRuns.GetImportCommitAsync(runId);
|
|
var blockers = new List<string>();
|
|
var warnings = new List<string>();
|
|
|
|
if (run.Status is not (StoryIntelligenceRunStatuses.Completed or StoryIntelligenceRunStatuses.CompletedWithWarnings))
|
|
{
|
|
blockers.Add("Only completed Story Intelligence runs can be committed.");
|
|
}
|
|
|
|
if (run.ProjectID is null || run.BookID is null || run.ChapterID is null)
|
|
{
|
|
blockers.Add("The run must have a project, book and chapter before it can create scenes.");
|
|
}
|
|
|
|
var sceneResults = await storyRuns.ListSceneResultsAsync(runId);
|
|
if (sceneResults.Count == 0)
|
|
{
|
|
blockers.Add("No saved scene results are available to import.");
|
|
}
|
|
|
|
var readiness = run.ChapterID.HasValue
|
|
? await storyRuns.GetChapterImportReadinessAsync(run.ChapterID.Value)
|
|
: null;
|
|
if (readiness is not null && !readiness.CanCommit)
|
|
{
|
|
blockers.Add(readiness.BlockReason ?? "This chapter already contains scenes.");
|
|
}
|
|
|
|
if (existingCommit is not null && string.Equals(existingCommit.Status, StoryIntelligenceImportCommitStatuses.Completed, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
blockers.Add("This Story Intelligence run has already been committed.");
|
|
}
|
|
|
|
var lookupData = await lookups.GetAllAsync();
|
|
var activeMetricTypes = run.ProjectID.HasValue
|
|
? (await metricTypes.ListForManagementAsync(run.ProjectID.Value)).Where(metric => metric.IsActive).ToList()
|
|
: [];
|
|
var noteTypes = await writerWorkspace.ListNoteTypesAsync();
|
|
var characterMap = run.ProjectID.HasValue
|
|
? await BuildCharacterMapAsync(run.ProjectID.Value)
|
|
: new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
var timeModeId = FindId(lookupData.TimeModes, item => item.TimeModeName, item => item.TimeModeID, "Relative", "Unknown");
|
|
var timeConfidenceId = FindId(lookupData.TimeConfidences, item => item.TimeConfidenceName, item => item.TimeConfidenceID, "Implied", "Unknown");
|
|
var revisionStatusId = FindId(lookupData.RevisionStatuses, item => item.StatusName, item => item.RevisionStatusID, "Planned");
|
|
var timelineNoteTypeId = noteTypes.FirstOrDefault(type => string.Equals(type.TypeName, "Timeline Note", StringComparison.OrdinalIgnoreCase))?.SceneNoteTypeID;
|
|
if (timelineNoteTypeId is null)
|
|
{
|
|
warnings.Add("Timeline clues will not be imported because the Timeline Note type is not available.");
|
|
}
|
|
|
|
var purposeMap = lookupData.ScenePurposeTypes.ToDictionary(type => Clean(type.PurposeName), type => type.ScenePurposeTypeID, StringComparer.OrdinalIgnoreCase);
|
|
var metricMap = BuildMetricMap(activeMetricTypes);
|
|
var importScenes = new List<StoryIntelligenceSceneImportItem>();
|
|
foreach (var sceneResult in sceneResults
|
|
.Where(scene => scene.ValidationErrorsCount == 0)
|
|
.OrderBy(scene => scene.TemporarySceneNumber))
|
|
{
|
|
var parsed = TryReadScene(sceneResult);
|
|
if (parsed is null)
|
|
{
|
|
warnings.Add($"Scene {sceneResult.TemporarySceneNumber:N0} could not be prepared automatically and needs review.");
|
|
continue;
|
|
}
|
|
|
|
importScenes.Add(BuildImportScene(sceneResult, parsed, characterMap, purposeMap, metricMap));
|
|
}
|
|
|
|
if (importScenes.Count == 0)
|
|
{
|
|
blockers.Add("No scenes are ready to create for this chapter.");
|
|
}
|
|
|
|
var projectName = run.ProjectID.HasValue ? (await projects.GetAsync(run.ProjectID.Value))?.ProjectName ?? $"Project {run.ProjectID.Value:N0}" : "None";
|
|
var bookTitle = run.BookID.HasValue ? (await books.GetAsync(run.BookID.Value))?.BookDisplayTitle ?? $"Book {run.BookID.Value:N0}" : "None";
|
|
var chapter = run.ChapterID.HasValue ? await chapters.GetAsync(run.ChapterID.Value) : null;
|
|
var chapterLabel = chapter is null
|
|
? "None"
|
|
: string.IsNullOrWhiteSpace(chapter.ChapterTitle)
|
|
? $"Chapter {chapter.ChapterNumber:0.##}"
|
|
: $"Chapter {chapter.ChapterNumber:0.##}: {chapter.ChapterTitle}";
|
|
|
|
return new PreparedImport(
|
|
run,
|
|
new StoryIntelligenceImportConfirmationViewModel
|
|
{
|
|
Run = run,
|
|
ExistingCommit = existingCommit,
|
|
ProjectName = projectName,
|
|
BookTitle = bookTitle,
|
|
ChapterLabel = chapterLabel,
|
|
ExistingSceneCount = readiness?.ActiveSceneCount ?? 0,
|
|
CommitMode = readiness?.CommitMode ?? string.Empty,
|
|
ScenesToCreate = importScenes.Count,
|
|
MetricsToImport = importScenes.Sum(scene => scene.Metrics.Count),
|
|
MetricNames = importScenes.SelectMany(scene => scene.Metrics.Select(metric => metric.MetricName)).Distinct(StringComparer.OrdinalIgnoreCase).OrderBy(name => name).ToList(),
|
|
Warnings = warnings,
|
|
Blockers = blockers,
|
|
Scenes = importScenes
|
|
},
|
|
importScenes,
|
|
timeModeId,
|
|
timeConfidenceId,
|
|
revisionStatusId,
|
|
timelineNoteTypeId);
|
|
}
|
|
|
|
private static StoryIntelligenceSceneImportItem BuildImportScene(
|
|
StoryIntelligenceSavedSceneResult sceneResult,
|
|
SceneIntelligenceScene parsed,
|
|
IReadOnlyDictionary<string, int> characterMap,
|
|
IReadOnlyDictionary<string, int> purposeMap,
|
|
IReadOnlyDictionary<string, SceneMetricType> metricMap)
|
|
{
|
|
var povName = Clean(parsed.PointOfView?.CharacterName);
|
|
var povCharacterId = !string.IsNullOrWhiteSpace(povName)
|
|
&& !string.Equals(povName, "Narrator", StringComparison.OrdinalIgnoreCase)
|
|
&& characterMap.TryGetValue(povName, out var characterId)
|
|
? characterId
|
|
: (int?)null;
|
|
var summary = Clean(parsed.Summary?.Short);
|
|
var sceneTitle = GenerateTitle(sceneResult.TemporarySceneNumber, summary);
|
|
|
|
return new StoryIntelligenceSceneImportItem
|
|
{
|
|
SceneResultID = sceneResult.SceneResultID,
|
|
TemporarySceneNumber = sceneResult.TemporarySceneNumber,
|
|
StartParagraph = sceneResult.StartParagraph,
|
|
EndParagraph = sceneResult.EndParagraph,
|
|
SourceLabel = sceneResult.SourceLabel,
|
|
ParsedScene = parsed,
|
|
PovCharacterID = povCharacterId,
|
|
PurposeTypeIDs = MatchPurposes(parsed.ScenePurpose?.ObservedFunction, purposeMap),
|
|
Metrics = BuildMetrics(parsed, metricMap),
|
|
SceneTitle = sceneTitle,
|
|
Summary = string.IsNullOrWhiteSpace(summary) ? null : summary,
|
|
PurposeNotes = BuildPurposeNotes(parsed, sceneResult, povName, povCharacterId),
|
|
OutcomeNotes = string.IsNullOrWhiteSpace(parsed.Summary?.Detailed) ? null : $"Detailed summary: {parsed.Summary.Detailed}",
|
|
ImportNoteText = BuildImportNote(parsed, povName, povCharacterId)
|
|
};
|
|
}
|
|
|
|
private async Task<Dictionary<string, int>> BuildCharacterMapAsync(int projectId)
|
|
{
|
|
var map = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var character in await characters.ListCharactersAsync(projectId))
|
|
{
|
|
AddCharacterMap(map, character.CharacterName, character.CharacterID);
|
|
AddCharacterMap(map, character.ShortName, character.CharacterID);
|
|
foreach (var alias in await characters.ListAliasesAsync(character.CharacterID))
|
|
{
|
|
AddCharacterMap(map, alias.Alias, character.CharacterID);
|
|
}
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private static void AddCharacterMap(Dictionary<string, int> map, string? name, int characterId)
|
|
{
|
|
var clean = Clean(name);
|
|
if (!string.IsNullOrWhiteSpace(clean))
|
|
{
|
|
map.TryAdd(clean, characterId);
|
|
}
|
|
}
|
|
|
|
private static Dictionary<string, SceneMetricType> BuildMetricMap(IReadOnlyList<SceneMetricType> metricTypes)
|
|
{
|
|
var byName = metricTypes.ToDictionary(metric => Clean(metric.MetricName), metric => metric, StringComparer.OrdinalIgnoreCase);
|
|
var map = new Dictionary<string, SceneMetricType>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var (schemaName, aliases) in MetricAliases)
|
|
{
|
|
var metric = aliases.Select(alias => byName.TryGetValue(Clean(alias), out var match) ? match : null).FirstOrDefault(match => match is not null);
|
|
if (metric is not null)
|
|
{
|
|
map[schemaName] = metric;
|
|
}
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private static IReadOnlyList<SceneMetricValue> BuildMetrics(SceneIntelligenceScene parsed, IReadOnlyDictionary<string, SceneMetricType> metricMap)
|
|
{
|
|
if (parsed.Metrics is null || parsed.Metrics.Count == 0)
|
|
{
|
|
return [];
|
|
}
|
|
|
|
var values = new List<SceneMetricValue>();
|
|
foreach (var (name, metric) in parsed.Metrics)
|
|
{
|
|
if (!metric.Score.HasValue || !metricMap.TryGetValue(name, out var metricType))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
values.Add(new SceneMetricValue
|
|
{
|
|
MetricTypeID = metricType.MetricTypeID,
|
|
MetricName = metricType.MetricName,
|
|
Value = Math.Clamp(metric.Score.Value, metricType.MinValue, metricType.MaxValue),
|
|
Notes = metric.Confidence.HasValue ? $"Story Intelligence confidence {metric.Confidence.Value:0.##}." : "Imported from Story Intelligence."
|
|
});
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
private static IReadOnlyList<int> MatchPurposes(string? observedFunction, IReadOnlyDictionary<string, int> purposeMap)
|
|
{
|
|
var value = Clean(observedFunction);
|
|
if (string.IsNullOrWhiteSpace(value))
|
|
{
|
|
return [];
|
|
}
|
|
|
|
var matches = purposeMap
|
|
.Where(pair => value.Contains(pair.Key, StringComparison.OrdinalIgnoreCase) || pair.Key.Contains(value, StringComparison.OrdinalIgnoreCase))
|
|
.Select(pair => pair.Value)
|
|
.Distinct()
|
|
.ToList();
|
|
return matches;
|
|
}
|
|
|
|
private static string? BuildPurposeNotes(SceneIntelligenceScene parsed, StoryIntelligenceSavedSceneResult result, string povName, int? povCharacterId)
|
|
{
|
|
var lines = new List<string>
|
|
{
|
|
$"Story Intelligence import source: run {result.StoryIntelligenceRunID:N0}, paragraphs {DisplayRange(result.StartParagraph, result.EndParagraph)}."
|
|
};
|
|
|
|
if (!string.IsNullOrWhiteSpace(parsed.ScenePurpose?.ObservedFunction))
|
|
{
|
|
lines.Add($"Observed function: {parsed.ScenePurpose.ObservedFunction}");
|
|
}
|
|
|
|
if (parsed.Setting is not null)
|
|
{
|
|
var setting = string.Join("; ", new[]
|
|
{
|
|
Label("Location", parsed.Setting.LocationName),
|
|
Label("Location type", parsed.Setting.LocationType),
|
|
Label("Room", parsed.Setting.GenericRoomType),
|
|
Label("Parent hint", parsed.Setting.ParentLocationHint),
|
|
Label("Time", parsed.Setting.DateOrTimeReference ?? parsed.Setting.TimeOfDay)
|
|
}.Where(value => !string.IsNullOrWhiteSpace(value)));
|
|
if (!string.IsNullOrWhiteSpace(setting))
|
|
{
|
|
lines.Add($"Setting notes: {setting}");
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(povName) && !povCharacterId.HasValue)
|
|
{
|
|
lines.Add($"POV not linked: {povName}");
|
|
}
|
|
|
|
return string.Join(Environment.NewLine, lines);
|
|
}
|
|
|
|
private static string? BuildImportNote(SceneIntelligenceScene parsed, string povName, int? povCharacterId)
|
|
{
|
|
var lines = new List<string>();
|
|
if (parsed.TimelineClues?.Count > 0)
|
|
{
|
|
lines.Add("Timeline clues:");
|
|
lines.AddRange(parsed.TimelineClues.Select(clue => $"- {Clean(clue.AbsoluteDate ?? clue.RelativeOrder ?? clue.Clue)}"));
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(povName) && !povCharacterId.HasValue)
|
|
{
|
|
lines.Add($"POV left unlinked because '{povName}' did not resolve to an existing character.");
|
|
}
|
|
|
|
return lines.Count == 0 ? null : string.Join(Environment.NewLine, lines);
|
|
}
|
|
|
|
private static SceneIntelligenceScene? TryReadScene(StoryIntelligenceSavedSceneResult result)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(result.ParsedJson))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
try
|
|
{
|
|
var direct = JsonSerializer.Deserialize<SceneIntelligenceScene>(result.ParsedJson, JsonOptions);
|
|
if (!string.IsNullOrWhiteSpace(direct?.SchemaVersion))
|
|
{
|
|
return direct;
|
|
}
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static int FindId<T>(IReadOnlyList<T> items, Func<T, string> name, Func<T, int> id, params string[] preferredNames)
|
|
{
|
|
foreach (var preferred in preferredNames)
|
|
{
|
|
var match = items.FirstOrDefault(item => string.Equals(name(item), preferred, StringComparison.OrdinalIgnoreCase));
|
|
if (match is not null)
|
|
{
|
|
return id(match);
|
|
}
|
|
}
|
|
|
|
return items.Count > 0 ? id(items[0]) : throw new InvalidOperationException("Required lookup data is missing.");
|
|
}
|
|
|
|
private static string GenerateTitle(int sceneNumber, string summary)
|
|
=> string.IsNullOrWhiteSpace(summary)
|
|
? $"Scene {sceneNumber:N0}"
|
|
: $"Scene {sceneNumber:N0} - {TrimTo(summary, 60)}";
|
|
|
|
private static string TrimTo(string value, int maxLength)
|
|
=> value.Length <= maxLength ? value : value[..maxLength].TrimEnd() + "...";
|
|
|
|
private static string DisplayRange(int? start, int? end)
|
|
=> start.HasValue && end.HasValue ? $"{start.Value:N0}-{end.Value:N0}" : "unknown";
|
|
|
|
private static string? Label(string label, string? value)
|
|
=> string.IsNullOrWhiteSpace(value) ? null : $"{label}: {value}";
|
|
|
|
private static string Clean(string? value)
|
|
=> string.Join(' ', (value ?? string.Empty).Trim().Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
|
|
|
|
private sealed record PreparedImport(
|
|
StoryIntelligenceSavedRun Run,
|
|
StoryIntelligenceImportConfirmationViewModel Confirmation,
|
|
IReadOnlyList<StoryIntelligenceSceneImportItem> Scenes,
|
|
int TimeModeID,
|
|
int TimeConfidenceID,
|
|
int RevisionStatusID,
|
|
int? TimelineNoteTypeID);
|
|
}
|