using Titano.Core.Imaging;
using Titano.Core.Model;
namespace Titano.Data.Repositories;
/// Orderings of the Library; every one is keyset-paginated with the sequence id as tie-breaker.
public enum SequenceSort
{
/// Latest first capture first; sequences without captures last.
Newest,
Oldest,
/// Display title, case-insensitive.
Title,
FrameCount,
Size,
}
/// Library filters (all optional, combined with AND) plus sort and page.
public sealed record SequenceQuery
{
public Guid? ArchiveId { get; init; }
/// Calendar year of the first capture.
public int? Year { get; init; }
/// Exact camera model.
public string? Camera { get; init; }
/// Status flags that must all be set.
public SequenceStatus WithStatus { get; init; }
/// Status flags that must all be clear.
public SequenceStatus WithoutStatus { get; init; }
public string? Tag { get; init; }
/// Case-insensitive substring of the title, camera make/model or a tag.
public string? Text { get; init; }
public Guid? OwnerUserId { get; init; }
public SequenceSort Sort { get; init; } = SequenceSort.Newest;
/// Page size, 1–1000.
public int Limit { get; init; } = 100;
/// of the previous page, or null for the first page.
public string? Cursor { get; init; }
}
/// Figures of the Archive screen (BRIEF §12.5).
public sealed record ArchiveStats(
int Sequences,
long Photos,
long Bytes,
IReadOnlyList ByYear,
IReadOnlyList ByMonth,
IReadOnlyList ByCamera,
IReadOnlyList ByFormat,
ArchiveHealth Health);
/// Fields a client may change on a sequence; null leaves a field unchanged, an empty title or notes clears it.
public sealed record SequenceEdit
{
public string? Title { get; init; }
public IReadOnlyList? Tags { get; init; }
public int? Rating { get; init; }
public string? Notes { get; init; }
public string? SettingsJson { get; init; }
}
public enum SequenceEditOutcome
{
Updated,
NotFound,
/// The settings version moved since the client read it.
Conflict,
}
/// Result of : the updated sequence, or the stored one on conflict.
public sealed record SequenceEditResult(SequenceEditOutcome Outcome, Sequence? Sequence);
public sealed record YearBucket(int Year, int Sequences, long Photos, long Bytes);
/// One heatmap cell: sequences and photos whose first capture falls in the month.
public sealed record MonthBucket(int Year, int Month, int Sequences, long Photos);
public sealed record CameraBucket(string? Make, string? Model, int Sequences, long Photos, long Bytes);
public sealed record FormatBucket(ImageFileFormat Format, long Photos, long Bytes);
/// Health counters: sequences needing attention and flagged frames.
public sealed record ArchiveHealth(
int Unverified,
int WithWarnings,
int WithErrors,
int NotAnalyzed,
long MissingFrames,
long CorruptFrames,
long DuplicateFrames);
/// Where a sequence lives in its archive.
public sealed record SequenceLocation(Guid Id, string Folder, string? Title);
/// Sequences (projects) with their tags; Library listing and Archive statistics.
public sealed class SequenceRepository
{
private const string Columns =
"s.id, s.archive_id, s.title, s.folder, s.camera_make, s.camera_model, s.camera_serial, s.lens, s.first_capture, s.last_capture, " +
"s.frame_count, s.median_interval, s.total_bytes, s.status, s.rendered_count, s.verified_at, s.hero_frame_id, s.rating, s.notes, " +
"s.settings_json, s.analysis_json, s.origin, s.sync_state, s.settings_version, s.frames_version, s.owner_user_id, s.warning_count, s.updated_at";
/// rendered_count is owned by once the row exists.
private static readonly string UpsertSql = SqlDialect.Upsert("sequences",
[
"id", "archive_id", "title", "title_key", "search_text", "folder", "camera_make", "camera_model", "camera_serial", "lens",
"first_capture", "last_capture", "frame_count", "median_interval", "total_bytes", "status", "rendered_count", "verified_at",
"hero_frame_id", "rating", "notes", "settings_json", "analysis_json", "origin", "sync_state", "settings_version",
"frames_version", "owner_user_id", "warning_count", "updated_at",
], 1, ["rendered_count"]);
/// Ordinal of the tag list after , and of the sort key a listing appends after it.
private const int TagsOrdinal = 28;
private const int SortKeyOrdinal = 29;
private readonly DbAccess _db;
private readonly string _select;
internal SequenceRepository(DbAccess db)
{
_db = db;
_select = SelectSql(string.Empty);
}
private string SelectSql(string extraColumns) =>
$"SELECT {Columns}, (SELECT {_db.Sql.StringAgg("t.name")} FROM sequence_tags st JOIN tags t ON t.id = st.tag_id " +
$"WHERE st.sequence_id = s.id) AS tags{extraColumns} FROM sequences s";
///
/// Inserts the sequence, or replaces every stored field and the tag set with the record's (last writer wins);
/// only of an existing row is kept, as renders maintain it. For concurrent
/// partial changes use , or .
///
public Task UpsertAsync(Sequence sequence, CancellationToken cancellationToken = default) =>
_db.InTransactionAsync(async session =>
{
await UpsertRowAsync(session, sequence, cancellationToken).ConfigureAwait(false);
await ReplaceTagsAsync(session, sequence.Id, sequence.Tags, cancellationToken).ConfigureAwait(false);
return true;
}, cancellationToken);
public Task GetAsync(Guid id, CancellationToken cancellationToken = default) =>
_db.SingleAsync($"{_select} WHERE s.id = $1", [id], Map, cancellationToken);
/// Deletes the sequence with its frames, renders and tag links.
public async Task DeleteAsync(Guid id, CancellationToken cancellationToken = default) =>
await _db.ExecuteAsync("DELETE FROM sequences WHERE id = $1", [id], cancellationToken).ConfigureAwait(false) > 0;
/// Replaces the tags of a sequence (trimmed, de-duplicated case-insensitively).
public async Task SetTagsAsync(Guid id, IEnumerable tags, CancellationToken cancellationToken = default) =>
await _db.InTransactionAsync(async session =>
{
if (!await LockAsync(session, id, cancellationToken).ConfigureAwait(false)) return false;
await ReplaceTagsAsync(session, id, tags, cancellationToken).ConfigureAwait(false);
await session.ExecuteAsync("UPDATE sequences SET settings_version = settings_version + 1, updated_at = $2 WHERE id = $1",
[id, DateTimeOffset.UtcNow], cancellationToken).ConfigureAwait(false);
return true;
}, cancellationToken).ConfigureAwait(false);
/// Sets and clears status flags in one statement.
public async Task UpdateStatusAsync(Guid id, SequenceStatus set, SequenceStatus clear, CancellationToken cancellationToken = default) =>
await _db.ExecuteAsync("UPDATE sequences SET status = (status | $2) & ~$3, updated_at = $4 WHERE id = $1",
[id, (int)set, (int)clear, DateTimeOffset.UtcNow], cancellationToken).ConfigureAwait(false) > 0;
///
/// Records an analysis: status flags set and cleared, the warning count and, for a deep analysis, the compact
/// summary ( null keeps the stored one).
///
public async Task RecordAnalysisAsync(Guid id, SequenceStatus set, SequenceStatus clear, int warningCount, string? analysisJson,
CancellationToken cancellationToken = default)
{
DbParam[] args = [id, (int)set, (int)clear, warningCount, DateTimeOffset.UtcNow];
var sql = "UPDATE sequences SET status = (status | $2) & ~$3, warning_count = $4, updated_at = $5";
if (analysisJson is not null)
{
sql += ", analysis_json = $6";
args = [.. args, DbParam.Json(analysisJson)];
}
return await _db.ExecuteAsync(sql + " WHERE id = $1", args, cancellationToken).ConfigureAwait(false) > 0;
}
/// Recomputes frame count, total bytes and first/last capture from the frames table.
public Task RefreshStatsAsync(Guid id, CancellationToken cancellationToken = default) =>
_db.InTransactionAsync(async session =>
{
var current = await session.QuerySingleOrDefaultAsync($"{_select} WHERE s.id = $1{_db.Sql.ForUpdate}", [id], Map, cancellationToken)
.ConfigureAwait(false);
if (current is null) return null;
var stats = await session.QuerySingleAsync(
"SELECT count(*), COALESCE(SUM(size), 0), MIN(captured_at), MAX(captured_at) FROM frames WHERE sequence_id = $1",
[id], cancellationToken).ConfigureAwait(false);
var updated = current with
{
FrameCount = (int)stats.GetInt64(0),
TotalBytes = stats.GetInt64(1),
FirstCapture = stats.GetDateTimeOrNull(2),
LastCapture = stats.GetDateTimeOrNull(3),
FramesVersion = current.FramesVersion + 1,
UpdatedAt = DateTimeOffset.UtcNow,
};
await UpsertRowAsync(session, updated, cancellationToken).ConfigureAwait(false);
return updated;
}, cancellationToken);
///
/// Applies a client edit atomically and bumps settings_version. With
/// the edit is refused (, carrying the stored sequence) when someone else
/// changed the sequence first (BRIEF §14.5).
///
public Task EditAsync(Guid id, SequenceEdit edit, int? expectedSettingsVersion, CancellationToken cancellationToken = default) =>
_db.InTransactionAsync(async session =>
{
var current = await session.QuerySingleOrDefaultAsync($"{_select} WHERE s.id = $1{_db.Sql.ForUpdate}", [id], Map, cancellationToken)
.ConfigureAwait(false);
if (current is null) return new SequenceEditResult(SequenceEditOutcome.NotFound, null);
if (expectedSettingsVersion is { } expected && expected != current.SettingsVersion)
return new SequenceEditResult(SequenceEditOutcome.Conflict, current);
var updated = current with
{
Title = edit.Title is null ? current.Title : NullIfEmpty(edit.Title),
Notes = edit.Notes is null ? current.Notes : NullIfEmpty(edit.Notes),
Rating = edit.Rating ?? current.Rating,
SettingsJson = edit.SettingsJson ?? current.SettingsJson,
SettingsVersion = current.SettingsVersion + 1,
UpdatedAt = DateTimeOffset.UtcNow,
};
await UpsertRowAsync(session, updated, cancellationToken).ConfigureAwait(false);
if (edit.Tags is not null) await ReplaceTagsAsync(session, id, edit.Tags, cancellationToken).ConfigureAwait(false);
var stored = await session.QuerySingleAsync($"{_select} WHERE s.id = $1", [id], cancellationToken).ConfigureAwait(false);
return new SequenceEditResult(SequenceEditOutcome.Updated, Map(stored));
}, cancellationToken);
/// Gives every sequence owned by to ; returns how many.
public Task ReassignOwnerAsync(Guid fromUserId, Guid toUserId, CancellationToken cancellationToken = default) =>
_db.ExecuteAsync("UPDATE sequences SET owner_user_id = $2 WHERE owner_user_id = $1", [fromUserId, toUserId], cancellationToken);
/// One page of sequences matching .
public Task> ListAsync(SequenceQuery query, CancellationToken cancellationToken = default)
{
var p = new SqlParameters();
var where = Filter(query, p);
var (column, descending) = SortKey(query.Sort);
var scope = "seq:" + query.Sort;
if (query.Cursor is not null)
{
var (value, id) = Cursor.Decode(scope, query.Cursor);
where.Add(Cursor.After(column, "s.id", descending, value, id, p.Add));
}
var limit = Cursor.ClampLimit(query.Limit);
var direction = descending ? "DESC" : "ASC";
var sql = $"{SelectSql($", {column} AS sort_key")}{Where(where)} " +
$"ORDER BY {column} {direction} NULLS LAST, s.id {direction} LIMIT {p.Add(limit + 1)}";
return _db.RunAsync(async session =>
{
var rows = await session.QueryListAsync(sql, p.ToArray(), r => (Item: Map(r), Key: SortValue(query.Sort, r)), cancellationToken).ConfigureAwait(false);
string? next = null;
if (rows.Count > limit)
{
rows.RemoveAt(limit);
next = Cursor.Encode(scope, rows[^1].Key, rows[^1].Item.Id);
}
return new Page(rows.ConvertAll(r => r.Item), next);
}, cancellationToken);
}
/// Number of sequences matching the filters of (sort and page ignored).
public async Task CountAsync(SequenceQuery query, CancellationToken cancellationToken = default)
{
var p = new SqlParameters();
var where = Filter(query, p);
return (int)await _db.ScalarAsync($"SELECT count(*) FROM sequences s{Where(where)}", p.ToArray(), cancellationToken).ConfigureAwait(false);
}
/// Totals, distributions and health counters of one archive, or of all archives.
public Task GetStatsAsync(Guid? archiveId = null, CancellationToken cancellationToken = default)
{
var sql = _db.Sql;
DbParam[] args = archiveId is { } a ? [a] : [];
var seqWhere = archiveId is null ? string.Empty : " WHERE s.archive_id = $1";
var seqAnd = archiveId is null ? " WHERE" : " WHERE s.archive_id = $1 AND";
var frameFrom = archiveId is null ? "frames f" : "frames f JOIN sequences s ON s.id = f.sequence_id WHERE s.archive_id = $1";
var year = sql.Year("s.first_capture");
return _db.RunAsync(async session =>
{
var totals = await session.QuerySingleAsync(
$"SELECT count(*), COALESCE(SUM(s.frame_count), 0), COALESCE(SUM(s.total_bytes), 0) FROM sequences s{seqWhere}",
args, cancellationToken).ConfigureAwait(false);
var byYear = await session.QueryListAsync(
$"SELECT {year}, count(*), COALESCE(SUM(s.frame_count), 0), COALESCE(SUM(s.total_bytes), 0) FROM sequences s" +
$"{seqAnd} s.first_capture IS NOT NULL GROUP BY 1 ORDER BY 1", args,
r => new YearBucket(r.GetInt32(0), r.GetInt32(1), r.GetInt64(2), r.GetInt64(3)), cancellationToken).ConfigureAwait(false);
var byMonth = await session.QueryListAsync(
$"SELECT {year}, {sql.Month("s.first_capture")}, count(*), COALESCE(SUM(s.frame_count), 0) FROM sequences s" +
$"{seqAnd} s.first_capture IS NOT NULL GROUP BY 1, 2 ORDER BY 1, 2", args,
r => new MonthBucket(r.GetInt32(0), r.GetInt32(1), r.GetInt32(2), r.GetInt64(3)), cancellationToken).ConfigureAwait(false);
var byCamera = await session.QueryListAsync(
$"SELECT s.camera_make, s.camera_model, count(*), COALESCE(SUM(s.frame_count), 0), COALESCE(SUM(s.total_bytes), 0) " +
$"FROM sequences s{seqWhere} GROUP BY s.camera_make, s.camera_model ORDER BY 4 DESC, 2 NULLS LAST, 1 NULLS LAST", args,
r => new CameraBucket(r.GetStringOrNull(0), r.GetStringOrNull(1), r.GetInt32(2), r.GetInt64(3), r.GetInt64(4)), cancellationToken).ConfigureAwait(false);
var byFormat = await session.QueryListAsync(
$"SELECT f.format, count(*), COALESCE(SUM(f.size), 0) FROM {frameFrom} GROUP BY f.format ORDER BY 2 DESC, 1", args,
r => new FormatBucket((ImageFileFormat)r.GetInt32(0), r.GetInt64(1), r.GetInt64(2)), cancellationToken).ConfigureAwait(false);
var sequenceHealth = await session.QuerySingleAsync(
"SELECT " +
"COALESCE(SUM(CASE WHEN s.verified_at IS NULL THEN 1 ELSE 0 END), 0), " +
$"COALESCE(SUM(CASE WHEN (s.status & {(int)SequenceStatus.HasWarnings}) <> 0 OR s.warning_count > 0 THEN 1 ELSE 0 END), 0), " +
$"COALESCE(SUM(CASE WHEN (s.status & {(int)SequenceStatus.HasErrors}) <> 0 THEN 1 ELSE 0 END), 0), " +
$"COALESCE(SUM(CASE WHEN (s.status & {(int)SequenceStatus.AnalyzedLight}) = 0 THEN 1 ELSE 0 END), 0) " +
$"FROM sequences s{seqWhere}", args, cancellationToken).ConfigureAwait(false);
var frameHealth = await session.QuerySingleAsync(
"SELECT " +
$"COALESCE(SUM(CASE WHEN (f.flags & {(int)FrameFlags.Missing}) <> 0 THEN 1 ELSE 0 END), 0), " +
$"COALESCE(SUM(CASE WHEN (f.flags & {(int)FrameFlags.Corrupt}) <> 0 THEN 1 ELSE 0 END), 0), " +
$"COALESCE(SUM(CASE WHEN (f.flags & {(int)FrameFlags.Duplicate}) <> 0 THEN 1 ELSE 0 END), 0) " +
$"FROM {frameFrom}", args, cancellationToken).ConfigureAwait(false);
return new ArchiveStats(
totals.GetInt32(0), totals.GetInt64(1), totals.GetInt64(2), byYear, byMonth, byCamera, byFormat,
new ArchiveHealth(
sequenceHealth.GetInt32(0), sequenceHealth.GetInt32(1), sequenceHealth.GetInt32(2), sequenceHealth.GetInt32(3),
frameHealth.GetInt64(0), frameHealth.GetInt64(1), frameHealth.GetInt64(2)));
}, cancellationToken);
}
/// Folder and title of every sequence of an archive, by folder.
public Task> ListLocationsAsync(Guid archiveId, CancellationToken cancellationToken = default) =>
_db.ListAsync("SELECT id, folder, title FROM sequences WHERE archive_id = $1 ORDER BY folder, id", [archiveId],
r => new SequenceLocation(r.GetGuid(0), r.GetString(1), r.GetStringOrNull(2)), cancellationToken);
/// The sequence created for a session key (automatic grouping of uploads and card sessions).
public Task FindBySessionKeyAsync(Guid archiveId, string sessionKey, CancellationToken cancellationToken = default) =>
_db.ScalarAsync("SELECT sequence_id FROM sequence_sessions WHERE archive_id = $1 AND session_key = $2",
[archiveId, sessionKey], cancellationToken);
/// Binds a session key to a sequence unless it is already bound; returns the sequence the key resolves to.
public Task MapSessionKeyAsync(Guid archiveId, string sessionKey, Guid sequenceId, CancellationToken cancellationToken = default) =>
_db.InTransactionAsync(async session =>
{
await session.ExecuteAsync(
"INSERT INTO sequence_sessions (archive_id, session_key, sequence_id) VALUES ($1, $2, $3) ON CONFLICT (archive_id, session_key) DO NOTHING",
[archiveId, sessionKey, sequenceId], cancellationToken).ConfigureAwait(false);
return (await session.ScalarAsync("SELECT sequence_id FROM sequence_sessions WHERE archive_id = $1 AND session_key = $2",
[archiveId, sessionKey], cancellationToken).ConfigureAwait(false))!.Value;
}, cancellationToken);
/// Moves a sequence to another folder and/or title (mass rename); false when it does not exist.
public Task RelocateAsync(Guid id, string folder, string? title, CancellationToken cancellationToken = default) =>
_db.InTransactionAsync(async session =>
{
var current = await session.QuerySingleOrDefaultAsync($"{_select} WHERE s.id = $1{_db.Sql.ForUpdate}", [id], Map, cancellationToken)
.ConfigureAwait(false);
if (current is null) return false;
var titleChanged = current.Title != title;
await UpsertRowAsync(session, current with
{
Folder = folder,
Title = title,
SettingsVersion = titleChanged ? current.SettingsVersion + 1 : current.SettingsVersion,
UpdatedAt = DateTimeOffset.UtcNow,
}, cancellationToken).ConfigureAwait(false);
return true;
}, cancellationToken);
private static List Filter(SequenceQuery query, SqlParameters p)
{
var where = new List();
if (query.ArchiveId is { } archive) where.Add($"s.archive_id = {p.Add(archive)}");
if (query.Year is { } year)
where.Add($"s.first_capture >= {p.Add(new DateTime(year, 1, 1))} AND s.first_capture < {p.Add(new DateTime(year + 1, 1, 1))}");
if (query.Camera is { } camera) where.Add($"s.camera_model = {p.Add(camera)}");
if (query.WithStatus != SequenceStatus.None)
{
var mask = p.Add((int)query.WithStatus);
where.Add($"(s.status & {mask}) = {mask}");
}
if (query.WithoutStatus != SequenceStatus.None) where.Add($"(s.status & {p.Add((int)query.WithoutStatus)}) = 0");
if (query.Tag is { } tag)
where.Add("EXISTS (SELECT 1 FROM sequence_tags st JOIN tags t ON t.id = st.tag_id " +
$"WHERE st.sequence_id = s.id AND t.name_key = {p.Add(TagRepository.Key(tag))})");
if (!string.IsNullOrWhiteSpace(query.Text))
{
var pattern = p.Add(SqlDialect.ContainsPattern(query.Text.Trim().ToLowerInvariant()));
where.Add($"(s.search_text LIKE {pattern} ESCAPE '\\' OR EXISTS (SELECT 1 FROM sequence_tags st JOIN tags t ON t.id = st.tag_id " +
$"WHERE st.sequence_id = s.id AND t.name_key LIKE {pattern} ESCAPE '\\'))");
}
if (query.OwnerUserId is { } owner) where.Add($"s.owner_user_id = {p.Add(owner)}");
return where;
}
private static string Where(List conditions) =>
conditions.Count == 0 ? string.Empty : " WHERE " + string.Join(" AND ", conditions);
private static (string Column, bool Descending) SortKey(SequenceSort sort) => sort switch
{
SequenceSort.Newest => ("s.first_capture", true),
SequenceSort.Oldest => ("s.first_capture", false),
SequenceSort.Title => ("s.title_key", false),
SequenceSort.FrameCount => ("s.frame_count", true),
SequenceSort.Size => ("s.total_bytes", true),
_ => throw new ArgumentOutOfRangeException(nameof(sort), sort, null),
};
private static object? SortValue(SequenceSort sort, DbRow row) => sort switch
{
SequenceSort.Newest or SequenceSort.Oldest => row.GetDateTimeOrNull(SortKeyOrdinal),
SequenceSort.Title => row.GetString(SortKeyOrdinal),
_ => row.GetInt64(SortKeyOrdinal),
};
private static Task UpsertRowAsync(IDbSession session, Sequence s, CancellationToken cancellationToken)
{
var search = string.Join(' ', new[] { s.Title, s.CameraMake, s.CameraModel }.Where(v => !string.IsNullOrWhiteSpace(v))).ToLowerInvariant();
return session.ExecuteAsync(UpsertSql,
[
s.Id, s.ArchiveId, s.Title, s.DisplayTitle.ToLowerInvariant(), search, s.Folder, s.CameraMake, s.CameraModel, s.CameraSerial, s.Lens,
Wall(s.FirstCapture), Wall(s.LastCapture), s.FrameCount, s.MedianInterval, s.TotalBytes, (int)s.Status, s.RenderedCount, s.VerifiedAt,
s.HeroFrameId, s.Rating, s.Notes, DbParam.Json(s.SettingsJson), DbParam.Json(s.AnalysisJson), (int)s.Origin, (int)s.SyncState,
s.SettingsVersion, s.FramesVersion, s.OwnerUserId, s.WarningCount, s.UpdatedAt,
], cancellationToken);
}
///
/// Row-locks a sequence for a read-modify-write (PostgreSQL; SQLite's write lock already serialises writers).
/// False when it does not exist.
///
internal static async Task LockAsync(IDbSession session, Guid id, CancellationToken cancellationToken) =>
await session.ScalarAsync($"SELECT id FROM sequences WHERE id = $1{SqlDialect.For(session.Dialect).ForUpdate}", [id], cancellationToken)
.ConfigureAwait(false) is not null;
/// Replaces the tag links of a sequence whose row the caller has locked (or just upserted).
private async Task ReplaceTagsAsync(IDbSession session, Guid sequenceId, IEnumerable tags, CancellationToken cancellationToken)
{
await session.ExecuteAsync("DELETE FROM sequence_tags WHERE sequence_id = $1", [sequenceId], cancellationToken).ConfigureAwait(false);
foreach (var tag in TagRepository.NormalizeSet(tags))
{
DbParam[] args = [Guid.CreateVersion7(), tag, TagRepository.Key(tag)];
Guid tagId;
if (_db.Sql.IsPostgres)
{
// The no-op update locks an existing tag, so a concurrent DeleteUnusedAsync cannot remove it before the link exists.
tagId = (await session.ScalarAsync(
"INSERT INTO tags (id, name, name_key) VALUES ($1, $2, $3) ON CONFLICT (name_key) DO UPDATE SET name_key = excluded.name_key RETURNING id",
args, cancellationToken).ConfigureAwait(false))!.Value;
}
else
{
await session.ExecuteAsync("INSERT INTO tags (id, name, name_key) VALUES ($1, $2, $3) ON CONFLICT (name_key) DO NOTHING",
args, cancellationToken).ConfigureAwait(false);
tagId = (await session.ScalarAsync("SELECT id FROM tags WHERE name_key = $1", [args[2]], cancellationToken).ConfigureAwait(false))!.Value;
}
await session.ExecuteAsync("INSERT INTO sequence_tags (sequence_id, tag_id) VALUES ($1, $2)", [sequenceId, tagId], cancellationToken)
.ConfigureAwait(false);
}
}
private static string? NullIfEmpty(string value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
/// Camera wall-clock times are stored without zone, whatever kind the caller's value has.
internal static DateTime? Wall(DateTime? value) =>
value is { } v ? DateTime.SpecifyKind(v, DateTimeKind.Unspecified) : null;
private static Sequence Map(DbRow r)
{
var tags = r.GetStringOrNull(TagsOrdinal) is { Length: > 0 } list ? list.Split(SqlDialect.ListSeparator) : [];
Array.Sort(tags, StringComparer.OrdinalIgnoreCase);
return new Sequence
{
Id = r.GetGuid(0),
ArchiveId = r.GetGuid(1),
Title = r.GetStringOrNull(2),
Folder = r.GetString(3),
CameraMake = r.GetStringOrNull(4),
CameraModel = r.GetStringOrNull(5),
CameraSerial = r.GetStringOrNull(6),
Lens = r.GetStringOrNull(7),
FirstCapture = r.GetDateTimeOrNull(8),
LastCapture = r.GetDateTimeOrNull(9),
FrameCount = r.GetInt32(10),
MedianInterval = r.GetDoubleOrNull(11),
TotalBytes = r.GetInt64(12),
Status = (SequenceStatus)r.GetInt32(13),
RenderedCount = r.GetInt32(14),
VerifiedAt = r.GetDateTimeOffsetOrNull(15),
HeroFrameId = r.GetGuidOrNull(16),
Rating = r.GetInt32(17),
Notes = r.GetStringOrNull(18),
SettingsJson = r.GetStringOrNull(19),
AnalysisJson = r.GetStringOrNull(20),
Origin = (SequenceOrigin)r.GetInt32(21),
SyncState = (SyncState)r.GetInt32(22),
SettingsVersion = r.GetInt32(23),
FramesVersion = r.GetInt32(24),
OwnerUserId = r.GetGuidOrNull(25),
WarningCount = r.GetInt32(26),
UpdatedAt = r.GetDateTimeOffset(27),
Tags = tags,
};
}
}