refactor!: rename Titano to Chronos and move CI and releases to Gitea (#6)
CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
The owner renamed the product and moved the repository to the self-hosted Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control, and asked for Actions and a first automatic release with the server package and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md). - Chronos everywhere: a byte-exact rename of contents and paths, then a per-language review of the forms the old name's ending had dictated. - Gitea instead of GitHub: the update check, licence, issue and support links read ChronosReleasesUrl; the update check takes the highest stable version, offers a pre-release build its final release and reports a repository it cannot see as a failed check. EULA, security policy and Gitea issue forms live at the repository root. - Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release, nightly image and performance gates in the .NET SDK container with git checkout and the system SQLite. The release cross-compiles the Windows programs, checks their icon, version and DPI manifest, packs installers and zips, publishes the Gitea release and pushes the server image (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows runner (WINDOWS_RUNNER). - New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the docker-exec script, which Gitea's service containers do not allow; the throw-away server runs without durability) and pe-check. - Timed tests take their budget from TestTiming (CHRONOS_TEST_TIME_FACTOR, 3 on the shared runner; the weekly performance gates keep theirs). BREAKING CHANGE: programs, settings, data folders, file types, environment variables and the Docker image use the new name; nothing is migrated from Titano, which never had a release. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
This commit was merged in pull request #6.
This commit is contained in:
1 parent
c99842cc86
commit
f2b58522b9
1801 files changed
+11804
-10676
No files matched your search
@@ -0,0 +1,584 @@
|
||||
using Chronos.Core.Imaging;
|
||||
using Chronos.Core.Model;
|
||||
|
||||
namespace Chronos.Data.Repositories;
|
||||
|
||||
/// <summary>Orderings of the Library; every one is keyset-paginated with the sequence id as tie-breaker.</summary>
|
||||
public enum SequenceSort
|
||||
{
|
||||
/// <summary>Latest first capture first; sequences without captures last.</summary>
|
||||
Newest,
|
||||
Oldest,
|
||||
|
||||
/// <summary>Display title, case-insensitive.</summary>
|
||||
Title,
|
||||
FrameCount,
|
||||
Size,
|
||||
}
|
||||
|
||||
/// <summary>Library filters (all optional, combined with AND) plus sort and page.</summary>
|
||||
public sealed record SequenceQuery
|
||||
{
|
||||
public Guid? ArchiveId { get; init; }
|
||||
|
||||
/// <summary>Calendar year of the first capture.</summary>
|
||||
public int? Year { get; init; }
|
||||
|
||||
/// <summary>Exact camera model.</summary>
|
||||
public string? Camera { get; init; }
|
||||
|
||||
/// <summary>Status flags that must all be set.</summary>
|
||||
public SequenceStatus WithStatus { get; init; }
|
||||
|
||||
/// <summary>Status flags that must all be clear.</summary>
|
||||
public SequenceStatus WithoutStatus { get; init; }
|
||||
|
||||
public string? Tag { get; init; }
|
||||
|
||||
/// <summary>True: with at least one render; false: without any; null: either.</summary>
|
||||
public bool? Rendered { get; init; }
|
||||
|
||||
/// <summary>Sync states of which the sequence must be in one; null or empty: any.</summary>
|
||||
public IReadOnlyCollection<SyncState>? SyncStates { get; init; }
|
||||
|
||||
/// <summary>Case-insensitive substring of the title, camera make/model or a tag.</summary>
|
||||
public string? Text { get; init; }
|
||||
|
||||
public Guid? OwnerUserId { get; init; }
|
||||
|
||||
public SequenceSort Sort { get; init; } = SequenceSort.Newest;
|
||||
|
||||
/// <summary>Page size, 1–1000.</summary>
|
||||
public int Limit { get; init; } = 100;
|
||||
|
||||
/// <summary><see cref="Page{T}.NextCursor"/> of the previous page, or null for the first page.</summary>
|
||||
public string? Cursor { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>Figures of the Archive screen (BRIEF §12.5).</summary>
|
||||
public sealed record ArchiveStats(
|
||||
int Sequences,
|
||||
long Photos,
|
||||
long Bytes,
|
||||
IReadOnlyList<YearBucket> ByYear,
|
||||
IReadOnlyList<MonthBucket> ByMonth,
|
||||
IReadOnlyList<CameraBucket> ByCamera,
|
||||
IReadOnlyList<FormatBucket> ByFormat,
|
||||
ArchiveHealth Health);
|
||||
|
||||
/// <summary>Fields a client may change on a sequence; null leaves a field unchanged, an empty title or notes clears it.</summary>
|
||||
public sealed record SequenceEdit
|
||||
{
|
||||
public string? Title { get; init; }
|
||||
public IReadOnlyList<string>? Tags { get; init; }
|
||||
public int? Rating { get; init; }
|
||||
public string? Notes { get; init; }
|
||||
public string? SettingsJson { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// The frame the Library shows for the sequence (the project's hero frame); <see cref="Guid.Empty"/> clears it, so
|
||||
/// the first frame shows. A frame of another sequence is ignored.
|
||||
/// </summary>
|
||||
public Guid? HeroFrameId { get; init; }
|
||||
}
|
||||
|
||||
public enum SequenceEditOutcome
|
||||
{
|
||||
Updated,
|
||||
NotFound,
|
||||
|
||||
/// <summary>The settings version moved since the client read it.</summary>
|
||||
Conflict,
|
||||
}
|
||||
|
||||
/// <summary>Result of <see cref="SequenceRepository.EditAsync"/>: the updated sequence, or the stored one on conflict.</summary>
|
||||
public sealed record SequenceEditResult(SequenceEditOutcome Outcome, Sequence? Sequence);
|
||||
|
||||
public sealed record YearBucket(int Year, int Sequences, long Photos, long Bytes);
|
||||
|
||||
/// <summary>One heatmap cell: sequences and photos whose first capture falls in the month.</summary>
|
||||
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);
|
||||
|
||||
/// <summary>Health counters: sequences needing attention and flagged frames.</summary>
|
||||
public sealed record ArchiveHealth(
|
||||
int Unverified,
|
||||
int WithWarnings,
|
||||
int WithErrors,
|
||||
int NotAnalyzed,
|
||||
long MissingFrames,
|
||||
long CorruptFrames,
|
||||
long DuplicateFrames);
|
||||
|
||||
/// <summary>Where a sequence lives in its archive.</summary>
|
||||
public sealed record SequenceLocation(Guid Id, string Folder, string? Title);
|
||||
|
||||
/// <summary>Sequences (projects) with their tags; Library listing and Archive statistics.</summary>
|
||||
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, " +
|
||||
"s.preview_only_count";
|
||||
|
||||
/// <summary>rendered_count is owned by <see cref="RenderRepository"/> once the row exists.</summary>
|
||||
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", "preview_only_count",
|
||||
], 1, ["rendered_count"]);
|
||||
|
||||
/// <summary>Ordinal of the tag list after <see cref="Columns"/>, and of the sort key a listing appends after it.</summary>
|
||||
private const int TagsOrdinal = 29;
|
||||
private const int SortKeyOrdinal = 30;
|
||||
|
||||
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";
|
||||
|
||||
/// <summary>
|
||||
/// Inserts the sequence, or replaces every stored field and the tag set with the record's (last writer wins);
|
||||
/// only <see cref="Sequence.RenderedCount"/> of an existing row is kept, as renders maintain it. For concurrent
|
||||
/// partial changes use <see cref="SetTagsAsync"/>, <see cref="UpdateStatusAsync"/> or <see cref="RefreshStatsAsync"/>.
|
||||
/// </summary>
|
||||
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<Sequence?> GetAsync(Guid id, CancellationToken cancellationToken = default) =>
|
||||
_db.SingleAsync($"{_select} WHERE s.id = $1", [id], Map, cancellationToken);
|
||||
|
||||
/// <summary>
|
||||
/// <see cref="GetAsync"/> inside a transaction, the row locked until it ends (PostgreSQL; SQLite's write lock already
|
||||
/// serialises writers): a transaction that writes the whole row back from this read cannot undo an edit that another
|
||||
/// one commits meanwhile, as <see cref="EditAsync(Guid, SequenceEdit, int?, int?, CancellationToken)"/> takes the same lock.
|
||||
/// A transaction that writes frames of the sequence takes this lock, or writes the row, before the frames: with one
|
||||
/// order no two of them wait for each other's rows (PostgreSQL would abort one with a deadlock).
|
||||
/// </summary>
|
||||
public Task<Sequence?> GetForUpdateAsync(Guid id, CancellationToken cancellationToken = default) =>
|
||||
_db.SingleAsync($"{_select} WHERE s.id = $1{_db.Sql.ForUpdate}", [id], Map, cancellationToken);
|
||||
|
||||
/// <summary>Deletes the sequence with its frames, renders and tag links.</summary>
|
||||
public async Task<bool> DeleteAsync(Guid id, CancellationToken cancellationToken = default) =>
|
||||
await _db.ExecuteAsync("DELETE FROM sequences WHERE id = $1", [id], cancellationToken).ConfigureAwait(false) > 0;
|
||||
|
||||
/// <summary>Replaces the tags of a sequence (trimmed, de-duplicated case-insensitively).</summary>
|
||||
public async Task<bool> SetTagsAsync(Guid id, IEnumerable<string> 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);
|
||||
|
||||
/// <summary>Sets and clears status flags in one statement.</summary>
|
||||
public async Task<bool> 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;
|
||||
|
||||
/// <summary>
|
||||
/// Records decode tiers written to the sequence's frames (<see cref="FrameRepository.UpdateTiersAsync"/>): the status
|
||||
/// flags in <paramref name="set"/> and the preview-only count, in one statement. The frames, their versions and the
|
||||
/// settings stay as they are, so an ingest or a settings edit committed meanwhile is never written back over.
|
||||
/// </summary>
|
||||
public async Task<bool> RecordTiersAsync(Guid id, SequenceStatus set, int previewOnlyCount, CancellationToken cancellationToken = default) =>
|
||||
await _db.ExecuteAsync("UPDATE sequences SET status = status | $2, preview_only_count = $3, updated_at = $4 WHERE id = $1",
|
||||
[id, (int)set, previewOnlyCount, DateTimeOffset.UtcNow], cancellationToken).ConfigureAwait(false) > 0;
|
||||
|
||||
/// <summary>
|
||||
/// Records a verify: status flags set and cleared and the verify time, in one statement; every other field stays as
|
||||
/// it is (<see cref="RecordTiersAsync"/>).
|
||||
/// </summary>
|
||||
public async Task<bool> RecordVerifiedAsync(Guid id, SequenceStatus set, SequenceStatus clear, DateTimeOffset verifiedAt,
|
||||
CancellationToken cancellationToken = default) =>
|
||||
await _db.ExecuteAsync("UPDATE sequences SET status = (status | $2) & ~$3, verified_at = $4, updated_at = $5 WHERE id = $1",
|
||||
[id, (int)set, (int)clear, verifiedAt, DateTimeOffset.UtcNow], cancellationToken).ConfigureAwait(false) > 0;
|
||||
|
||||
/// <summary>
|
||||
/// Records an analysis: status flags set and cleared, the warning count and, for a deep analysis, the compact
|
||||
/// summary (<paramref name="analysisJson"/> null keeps the stored one).
|
||||
/// </summary>
|
||||
public async Task<bool> 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;
|
||||
}
|
||||
|
||||
/// <summary>Recomputes frame count, total bytes and first/last capture from the frames table.</summary>
|
||||
public Task<Sequence?> 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);
|
||||
|
||||
/// <summary>
|
||||
/// Applies a client edit atomically and bumps <c>settings_version</c>. With <paramref name="expectedSettingsVersion"/>
|
||||
/// the edit is refused (<see cref="SequenceEditOutcome.Conflict"/>, carrying the stored sequence) when someone else
|
||||
/// changed the sequence first (BRIEF §14.5).
|
||||
/// </summary>
|
||||
public Task<SequenceEditResult> EditAsync(Guid id, SequenceEdit edit, int? expectedSettingsVersion, CancellationToken cancellationToken = default) =>
|
||||
EditAsync(id, edit, expectedSettingsVersion, null, cancellationToken);
|
||||
|
||||
/// <summary>
|
||||
/// <see cref="EditAsync(Guid, SequenceEdit, int?, CancellationToken)"/>, also refused when the sequence's frames
|
||||
/// version is no longer <paramref name="expectedFramesVersion"/>: settings naming frames by position were written
|
||||
/// against frames that changed since.
|
||||
/// </summary>
|
||||
public Task<SequenceEditResult> EditAsync(Guid id, SequenceEdit edit, int? expectedSettingsVersion, int? expectedFramesVersion,
|
||||
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)
|
||||
|| (expectedFramesVersion is { } frames && frames != current.FramesVersion))
|
||||
return new SequenceEditResult(SequenceEditOutcome.Conflict, current);
|
||||
var hero = current.HeroFrameId;
|
||||
if (edit.HeroFrameId == Guid.Empty) hero = null;
|
||||
else if (edit.HeroFrameId is { } frame && await session.ScalarAsync<long>("SELECT count(*) FROM frames WHERE id = $1 AND sequence_id = $2",
|
||||
[frame, id], cancellationToken).ConfigureAwait(false) > 0) hero = frame;
|
||||
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,
|
||||
HeroFrameId = hero,
|
||||
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);
|
||||
|
||||
/// <summary>Gives every sequence owned by <paramref name="fromUserId"/> to <paramref name="toUserId"/>; returns how many.</summary>
|
||||
public Task<int> 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);
|
||||
|
||||
/// <summary>One page of sequences matching <paramref name="query"/>.</summary>
|
||||
public Task<Page<Sequence>> 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<Sequence>(rows.ConvertAll(r => r.Item), next);
|
||||
}, cancellationToken);
|
||||
}
|
||||
|
||||
/// <summary>Number of sequences matching the filters of <paramref name="query"/> (sort and page ignored).</summary>
|
||||
public async Task<int> CountAsync(SequenceQuery query, CancellationToken cancellationToken = default)
|
||||
{
|
||||
var p = new SqlParameters();
|
||||
var where = Filter(query, p);
|
||||
return (int)await _db.ScalarAsync<long>($"SELECT count(*) FROM sequences s{Where(where)}", p.ToArray(), cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>Totals, distributions and health counters of one archive, or of all archives.</summary>
|
||||
public Task<ArchiveStats> 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);
|
||||
}
|
||||
|
||||
/// <summary>Folder and title of every sequence of an archive, by folder.</summary>
|
||||
public Task<IReadOnlyList<SequenceLocation>> 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);
|
||||
|
||||
/// <summary>The sequence created for a session key (automatic grouping of uploads and card sessions).</summary>
|
||||
public Task<Guid?> FindBySessionKeyAsync(Guid archiveId, string sessionKey, CancellationToken cancellationToken = default) =>
|
||||
_db.ScalarAsync<Guid?>("SELECT sequence_id FROM sequence_sessions WHERE archive_id = $1 AND session_key = $2",
|
||||
[archiveId, sessionKey], cancellationToken);
|
||||
|
||||
/// <summary>Binds a session key to a sequence unless it is already bound; returns the sequence the key resolves to.</summary>
|
||||
public Task<Guid> 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<Guid?>("SELECT sequence_id FROM sequence_sessions WHERE archive_id = $1 AND session_key = $2",
|
||||
[archiveId, sessionKey], cancellationToken).ConfigureAwait(false))!.Value;
|
||||
}, cancellationToken);
|
||||
|
||||
/// <summary>
|
||||
/// Moves a sequence to another folder and, with <paramref name="title"/>, retitles it (mass rename; settings version
|
||||
/// + 1 when the title changes); every other field stays as the locked row has it. False when it does not exist.
|
||||
/// </summary>
|
||||
/// <param name="title">The new title; null keeps the current one.</param>
|
||||
public Task<bool> 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 retitled = title is not null && current.Title != title;
|
||||
await UpsertRowAsync(session, current with
|
||||
{
|
||||
Folder = folder,
|
||||
Title = retitled ? title : current.Title,
|
||||
SettingsVersion = retitled ? current.SettingsVersion + 1 : current.SettingsVersion,
|
||||
UpdatedAt = DateTimeOffset.UtcNow,
|
||||
}, cancellationToken).ConfigureAwait(false);
|
||||
return true;
|
||||
}, cancellationToken);
|
||||
|
||||
private static List<string> Filter(SequenceQuery query, SqlParameters p)
|
||||
{
|
||||
var where = new List<string>();
|
||||
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.Rendered is { } rendered) where.Add(rendered ? "s.rendered_count > 0" : "s.rendered_count = 0");
|
||||
if (query.SyncStates is { Count: > 0 } states) where.Add($"s.sync_state IN ({string.Join(", ", states.Select(state => p.Add((int)state)))})");
|
||||
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<string> 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<int> 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, s.PreviewOnlyCount,
|
||||
], cancellationToken);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Row-locks a sequence for a read-modify-write (PostgreSQL; SQLite's write lock already serialises writers).
|
||||
/// False when it does not exist.
|
||||
/// </summary>
|
||||
internal static async Task<bool> LockAsync(IDbSession session, Guid id, CancellationToken cancellationToken) =>
|
||||
await session.ScalarAsync<Guid?>($"SELECT id FROM sequences WHERE id = $1{SqlDialect.For(session.Dialect).ForUpdate}", [id], cancellationToken)
|
||||
.ConfigureAwait(false) is not null;
|
||||
|
||||
/// <summary>
|
||||
/// Replaces the tag links of a sequence whose row the caller has locked (or just upserted); a set the sequence already
|
||||
/// carries (names compared case-insensitively) is left as it is. On PostgreSQL every tag written is locked until
|
||||
/// commit, and the tags are written in the order of their keys whatever order the caller listed them in (a PATCH sends
|
||||
/// them in any order): writers of two sequences that share tags then take those rows in one order, and never wait for
|
||||
/// each other's (PostgreSQL would abort one with a deadlock, and nothing retries it).
|
||||
/// </summary>
|
||||
private async Task ReplaceTagsAsync(IDbSession session, Guid sequenceId, IEnumerable<string> tags, CancellationToken cancellationToken)
|
||||
{
|
||||
var wanted = TagRepository.NormalizeSet(tags);
|
||||
var keys = wanted.Select(TagRepository.Key).ToList();
|
||||
var stored = await session.QueryListAsync("SELECT t.name_key FROM sequence_tags st JOIN tags t ON t.id = st.tag_id WHERE st.sequence_id = $1",
|
||||
[sequenceId], r => r.GetString(0), cancellationToken).ConfigureAwait(false);
|
||||
if (stored.Count == keys.Count && stored.ToHashSet(StringComparer.Ordinal).SetEquals(keys)) return;
|
||||
await session.ExecuteAsync("DELETE FROM sequence_tags WHERE sequence_id = $1", [sequenceId], cancellationToken).ConfigureAwait(false);
|
||||
foreach (var tag in wanted.OrderBy(TagRepository.Key, StringComparer.Ordinal))
|
||||
{
|
||||
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<Guid?>(
|
||||
"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<Guid?>("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();
|
||||
|
||||
/// <summary>Camera wall-clock times are stored without zone, whatever kind the caller's value has.</summary>
|
||||
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),
|
||||
PreviewOnlyCount = r.GetInt32(28),
|
||||
Tags = tags,
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user