Initial jellyfin-multilang rewrite

This commit is contained in:
ajp_anton committed 2026-05-31 18:28:04 +00:00
commit 63dbc3a6d4
32 files changed
+9326

No files matched your search

@@ -0,0 +1,747 @@
using System.Globalization;
using System.Text.Json;
using Jellyfin.Plugin.Multilang.Services.Refresh;
using Jellyfin.Plugin.Multilang.Services.Providers;
using MediaBrowser.Common.Configuration;
using Microsoft.Data.Sqlite;
namespace Jellyfin.Plugin.Multilang.Data;
public sealed class TranslationStore
{
private readonly string _dbPath;
public TranslationStore(IApplicationPaths appPaths)
{
var dir = Path.Combine(appPaths.DataPath, "multilang");
Directory.CreateDirectory(dir);
Directory.CreateDirectory(Path.Combine(dir, "assets"));
_dbPath = Path.Combine(dir, "translations.sqlite");
Initialize();
}
public static string ToItemId32(Guid id)
=> id.ToString("N", CultureInfo.InvariantCulture).ToLowerInvariant();
public static long NowUnixUtc()
=> DateTimeOffset.UtcNow.ToUnixTimeSeconds();
public static string JsonArray(IEnumerable<string> values)
=> JsonSerializer.Serialize(values.Where(v => !string.IsNullOrWhiteSpace(v)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray());
public SqliteConnection Open()
=> new($"Data Source={_dbPath};Cache=Shared");
private void Initialize()
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
CREATE TABLE IF NOT EXISTS facts (
item_id TEXT PRIMARY KEY,
tmdb_id TEXT NOT NULL,
kind TEXT NOT NULL,
original_title TEXT NOT NULL DEFAULT '',
original_language TEXT NOT NULL DEFAULT '',
original_language_all TEXT NOT NULL DEFAULT '',
origin_countries_json TEXT NOT NULL DEFAULT '[]',
production_countries_json TEXT NOT NULL DEFAULT '[]',
spoken_languages_json TEXT NOT NULL DEFAULT '[]',
audio_track_language TEXT NOT NULL DEFAULT '',
genre_tmdb_ids_json TEXT NOT NULL DEFAULT '[]',
missing_checked_at INTEGER NOT NULL DEFAULT 0,
full_checked_at INTEGER NOT NULL DEFAULT 0
);
CREATE INDEX IF NOT EXISTS idx_facts_tmdb ON facts(tmdb_id);
CREATE INDEX IF NOT EXISTS idx_facts_kind ON facts(kind);
CREATE INDEX IF NOT EXISTS idx_facts_missing ON facts(missing_checked_at);
CREATE INDEX IF NOT EXISTS idx_facts_full ON facts(full_checked_at);
CREATE TABLE IF NOT EXISTS translations (
item_id TEXT NOT NULL,
lang TEXT NOT NULL,
field TEXT NOT NULL,
text TEXT NOT NULL,
PRIMARY KEY (item_id, lang, field)
);
CREATE INDEX IF NOT EXISTS idx_translations_item ON translations(item_id);
CREATE TABLE IF NOT EXISTS assets (
item_id TEXT NOT NULL,
lang TEXT NOT NULL,
kind TEXT NOT NULL,
path TEXT NOT NULL,
path_low TEXT NOT NULL DEFAULT '',
updated_at INTEGER NOT NULL,
PRIMARY KEY (item_id, lang, kind)
);
CREATE INDEX IF NOT EXISTS idx_assets_item ON assets(item_id);
CREATE TABLE IF NOT EXISTS genres (
tmdb_id INTEGER NOT NULL,
media TEXT NOT NULL,
lang TEXT NOT NULL,
name TEXT NOT NULL,
name_norm TEXT NOT NULL,
PRIMARY KEY (tmdb_id, media, lang)
);
CREATE INDEX IF NOT EXISTS idx_genres_media_lang ON genres(media, lang);
CREATE INDEX IF NOT EXISTS idx_genres_name ON genres(name_norm, media, lang);
CREATE TABLE IF NOT EXISTS user_rules (
user_id TEXT PRIMARY KEY,
rules_json TEXT NOT NULL,
updated_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS user_display_langs (
user_id TEXT PRIMARY KEY,
langs_json TEXT NOT NULL,
updated_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS scan_state (
id INTEGER PRIMARY KEY CHECK (id = 1),
last_scan_started INTEGER NOT NULL DEFAULT 0
);
INSERT OR IGNORE INTO scan_state(id, last_scan_started) VALUES (1, 0);
";
cmd.ExecuteNonQuery();
EnsureColumn(con, "assets", "path_low", "TEXT NOT NULL DEFAULT ''");
}
private static void EnsureColumn(SqliteConnection con, string table, string column, string definition)
{
using (var info = con.CreateCommand())
{
info.CommandText = $"PRAGMA table_info({table});";
using var reader = info.ExecuteReader();
while (reader.Read())
{
if (reader.GetString(1).Equals(column, StringComparison.OrdinalIgnoreCase))
return;
}
}
using var alter = con.CreateCommand();
alter.CommandText = $"ALTER TABLE {table} ADD COLUMN {column} {definition};";
alter.ExecuteNonQuery();
}
public HashSet<string> GetTrackedItemIds()
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = "SELECT item_id FROM facts;";
using var reader = cmd.ExecuteReader();
var ids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
while (reader.Read())
ids.Add(reader.GetString(0));
return ids;
}
public void CleanupNotInLibrary(IReadOnlySet<string> liveItemIds)
{
using var con = Open();
con.Open();
using var tx = con.BeginTransaction();
using var select = con.CreateCommand();
select.Transaction = tx;
select.CommandText = "SELECT item_id FROM facts;";
using var reader = select.ExecuteReader();
var stale = new List<string>();
while (reader.Read())
{
var itemId = reader.GetString(0);
if (!liveItemIds.Contains(itemId))
stale.Add(itemId);
}
reader.Close();
foreach (var itemId in stale)
{
using var delete = con.CreateCommand();
delete.Transaction = tx;
delete.CommandText = @"
DELETE FROM facts WHERE item_id = $item_id;
DELETE FROM translations WHERE item_id = $item_id;
DELETE FROM assets WHERE item_id = $item_id;";
delete.Parameters.AddWithValue("$item_id", itemId);
delete.ExecuteNonQuery();
}
tx.Commit();
}
public long GetLastScanStarted()
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = "SELECT last_scan_started FROM scan_state WHERE id = 1;";
return cmd.ExecuteScalar() is long value ? value : 0;
}
public void SetLastScanStarted(long value)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
INSERT INTO scan_state(id, last_scan_started)
VALUES(1, $value)
ON CONFLICT(id) DO UPDATE SET last_scan_started = excluded.last_scan_started;";
cmd.Parameters.AddWithValue("$value", value);
cmd.ExecuteNonQuery();
}
public FactsStatus GetFactsStatus(string itemId)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = "SELECT missing_checked_at, full_checked_at FROM facts WHERE item_id = $item_id;";
cmd.Parameters.AddWithValue("$item_id", itemId);
using var reader = cmd.ExecuteReader();
return reader.Read()
? new FactsStatus(true, reader.GetInt64(0), reader.GetInt64(1))
: new FactsStatus(false, 0, 0);
}
public HashSet<string> GetExistingFactsItemIds(IEnumerable<string> itemIds)
{
var ids = itemIds.Where(i => !string.IsNullOrWhiteSpace(i)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
var result = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
if (ids.Length == 0)
return result;
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
var idParams = AddParams(cmd, ids, "$id");
cmd.CommandText = $"SELECT item_id FROM facts WHERE item_id IN ({idParams});";
using var reader = cmd.ExecuteReader();
while (reader.Read())
result.Add(reader.GetString(0));
return result;
}
public void UpsertFacts(RefreshItemInfo item, TmdbMetadata metadata, long missingCheckedAt, long fullCheckedAt)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
INSERT INTO facts(
item_id, tmdb_id, kind, original_title, original_language, original_language_all,
origin_countries_json, production_countries_json, spoken_languages_json, audio_track_language,
genre_tmdb_ids_json, missing_checked_at, full_checked_at)
VALUES(
$item_id, $tmdb_id, $kind, $original_title, $original_language, $original_language_all,
$origin_countries_json, $production_countries_json, $spoken_languages_json, $audio_track_language,
$genre_tmdb_ids_json, $missing_checked_at, $full_checked_at)
ON CONFLICT(item_id) DO UPDATE SET
tmdb_id = excluded.tmdb_id,
kind = excluded.kind,
original_title = excluded.original_title,
original_language = excluded.original_language,
original_language_all = excluded.original_language_all,
origin_countries_json = excluded.origin_countries_json,
production_countries_json = excluded.production_countries_json,
spoken_languages_json = excluded.spoken_languages_json,
audio_track_language = excluded.audio_track_language,
genre_tmdb_ids_json = excluded.genre_tmdb_ids_json,
missing_checked_at = excluded.missing_checked_at,
full_checked_at = CASE WHEN excluded.full_checked_at > 0 THEN excluded.full_checked_at ELSE facts.full_checked_at END;";
cmd.Parameters.AddWithValue("$item_id", item.ItemId);
cmd.Parameters.AddWithValue("$tmdb_id", item.TmdbId);
cmd.Parameters.AddWithValue("$kind", item.Kind);
cmd.Parameters.AddWithValue("$original_title", metadata.OriginalTitle);
cmd.Parameters.AddWithValue("$original_language", metadata.OriginalLanguage);
cmd.Parameters.AddWithValue("$original_language_all", metadata.OriginalLanguage);
cmd.Parameters.AddWithValue("$origin_countries_json", JsonArray(metadata.OriginCountries));
cmd.Parameters.AddWithValue("$production_countries_json", JsonArray(metadata.ProductionCountries));
cmd.Parameters.AddWithValue("$spoken_languages_json", JsonArray(metadata.SpokenLanguages));
cmd.Parameters.AddWithValue("$audio_track_language", item.AudioLanguage ?? string.Empty);
cmd.Parameters.AddWithValue("$genre_tmdb_ids_json", JsonSerializer.Serialize(metadata.GenreIds));
cmd.Parameters.AddWithValue("$missing_checked_at", missingCheckedAt);
cmd.Parameters.AddWithValue("$full_checked_at", fullCheckedAt);
cmd.ExecuteNonQuery();
}
public void MarkFactsChecked(RefreshItemInfo item, long missingCheckedAt, long fullCheckedAt)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
INSERT INTO facts(
item_id, tmdb_id, kind, original_title, original_language, original_language_all,
origin_countries_json, production_countries_json, spoken_languages_json, audio_track_language,
genre_tmdb_ids_json, missing_checked_at, full_checked_at)
VALUES(
$item_id, $tmdb_id, $kind, '', '', '',
'[]', '[]', '[]', '',
'[]', $missing_checked_at, $full_checked_at)
ON CONFLICT(item_id) DO UPDATE SET
tmdb_id = excluded.tmdb_id,
kind = excluded.kind,
missing_checked_at = excluded.missing_checked_at,
full_checked_at = CASE WHEN excluded.full_checked_at > 0 THEN excluded.full_checked_at ELSE facts.full_checked_at END;";
cmd.Parameters.AddWithValue("$item_id", item.ItemId);
cmd.Parameters.AddWithValue("$tmdb_id", item.TmdbId);
cmd.Parameters.AddWithValue("$kind", item.Kind);
cmd.Parameters.AddWithValue("$missing_checked_at", missingCheckedAt);
cmd.Parameters.AddWithValue("$full_checked_at", fullCheckedAt);
cmd.ExecuteNonQuery();
}
public FactsData? GetFacts(string itemId)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
SELECT item_id, tmdb_id, kind, original_title, original_language, original_language_all,
origin_countries_json, production_countries_json, spoken_languages_json,
audio_track_language, genre_tmdb_ids_json, missing_checked_at, full_checked_at
FROM facts
WHERE item_id = $item_id;";
cmd.Parameters.AddWithValue("$item_id", itemId);
using var reader = cmd.ExecuteReader();
return reader.Read()
? new FactsData(
reader.GetString(0),
reader.GetString(1),
reader.GetString(2),
reader.GetString(3),
reader.GetString(4),
reader.GetString(5),
reader.GetString(6),
reader.GetString(7),
reader.GetString(8),
reader.GetString(9),
reader.GetString(10),
reader.GetInt64(11),
reader.GetInt64(12))
: null;
}
public Dictionary<string, FactsData> GetFactsForItems(IEnumerable<string> itemIds)
{
var ids = itemIds.Where(i => !string.IsNullOrWhiteSpace(i)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
var result = new Dictionary<string, FactsData>(StringComparer.OrdinalIgnoreCase);
if (ids.Length == 0)
return result;
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
var idParams = AddParams(cmd, ids, "$id");
cmd.CommandText = $@"
SELECT item_id, tmdb_id, kind, original_title, original_language, original_language_all,
origin_countries_json, production_countries_json, spoken_languages_json,
audio_track_language, genre_tmdb_ids_json, missing_checked_at, full_checked_at
FROM facts
WHERE item_id IN ({idParams});";
using var reader = cmd.ExecuteReader();
while (reader.Read())
{
var facts = new FactsData(
reader.GetString(0),
reader.GetString(1),
reader.GetString(2),
reader.GetString(3),
reader.GetString(4),
reader.GetString(5),
reader.GetString(6),
reader.GetString(7),
reader.GetString(8),
reader.GetString(9),
reader.GetString(10),
reader.GetInt64(11),
reader.GetInt64(12));
result[facts.ItemId] = facts;
}
return result;
}
public object[] GetTranslationsForDebug(string itemId)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = "SELECT lang, field, text FROM translations WHERE item_id = $item_id ORDER BY lang, field;";
cmd.Parameters.AddWithValue("$item_id", itemId);
using var reader = cmd.ExecuteReader();
var rows = new List<object>();
while (reader.Read())
rows.Add(new { Lang = reader.GetString(0), Field = reader.GetString(1), Text = reader.GetString(2) });
return rows.ToArray();
}
public void UpsertTranslation(string itemId, string lang, string field, string text)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
INSERT INTO translations(item_id, lang, field, text)
VALUES($item_id, $lang, $field, $text)
ON CONFLICT(item_id, lang, field) DO UPDATE SET text = excluded.text;";
cmd.Parameters.AddWithValue("$item_id", itemId);
cmd.Parameters.AddWithValue("$lang", lang);
cmd.Parameters.AddWithValue("$field", field);
cmd.Parameters.AddWithValue("$text", text);
cmd.ExecuteNonQuery();
}
public void UpsertAsset(string itemId, string lang, string kind, string path, long updatedAt)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
INSERT INTO assets(item_id, lang, kind, path, path_low, updated_at)
VALUES($item_id, $lang, $kind, $path, $path_low, $updated_at)
ON CONFLICT(item_id, lang, kind) DO UPDATE SET
path = excluded.path,
path_low = excluded.path_low,
updated_at = excluded.updated_at;";
cmd.Parameters.AddWithValue("$item_id", itemId);
cmd.Parameters.AddWithValue("$lang", lang);
cmd.Parameters.AddWithValue("$kind", kind);
cmd.Parameters.AddWithValue("$path", path);
cmd.Parameters.AddWithValue("$path_low", path.ToLowerInvariant());
cmd.Parameters.AddWithValue("$updated_at", updatedAt);
cmd.ExecuteNonQuery();
}
public void UpsertGenre(int tmdbId, string media, string lang, string name)
{
if (tmdbId <= 0 || string.IsNullOrWhiteSpace(media) || string.IsNullOrWhiteSpace(lang) || string.IsNullOrWhiteSpace(name))
return;
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
INSERT INTO genres(tmdb_id, media, lang, name, name_norm)
VALUES($tmdb_id, $media, $lang, $name, $name_norm)
ON CONFLICT(tmdb_id, media, lang) DO UPDATE SET
name = excluded.name,
name_norm = excluded.name_norm;";
cmd.Parameters.AddWithValue("$tmdb_id", tmdbId);
cmd.Parameters.AddWithValue("$media", media.Trim().ToLowerInvariant());
cmd.Parameters.AddWithValue("$lang", lang.Trim());
cmd.Parameters.AddWithValue("$name", name.Trim());
cmd.Parameters.AddWithValue("$name_norm", name.Trim().ToLowerInvariant());
cmd.ExecuteNonQuery();
}
public GenreRow[] GetGenres(string media)
{
if (string.IsNullOrWhiteSpace(media))
return [];
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = @"
SELECT tmdb_id, media, lang, name
FROM genres
WHERE media = $media
ORDER BY tmdb_id, lang;";
cmd.Parameters.AddWithValue("$media", media.Trim().ToLowerInvariant());
using var reader = cmd.ExecuteReader();
var rows = new List<GenreRow>();
while (reader.Read())
rows.Add(new GenreRow(reader.GetInt32(0), reader.GetString(1), reader.GetString(2), reader.GetString(3)));
return rows.ToArray();
}
public Dictionary<int, string> GetGenreNames(string media, string lang)
{
if (string.IsNullOrWhiteSpace(media))
return [];
var rows = GetGenres(media)
.GroupBy(r => r.TmdbId)
.Select(g => new { Id = g.Key, Name = PickGenreName(g, lang) })
.Where(g => !string.IsNullOrWhiteSpace(g.Name))
.ToDictionary(g => g.Id, g => g.Name, EqualityComparer<int>.Default);
return rows;
}
private static string PickGenreName(IEnumerable<GenreRow> rows, string lang)
{
var candidates = rows.ToArray();
var requested = (lang ?? string.Empty).Trim();
var requestedBase = requested.Split('-', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? string.Empty;
return candidates.FirstOrDefault(r => r.Lang.Equals(requested, StringComparison.OrdinalIgnoreCase)).Name ??
candidates.FirstOrDefault(r => !string.IsNullOrWhiteSpace(requestedBase) && r.Lang.Equals(requestedBase, StringComparison.OrdinalIgnoreCase)).Name ??
candidates.FirstOrDefault(r => r.Lang.Equals("en-US", StringComparison.OrdinalIgnoreCase)).Name ??
candidates.FirstOrDefault(r => r.Lang.Equals("en", StringComparison.OrdinalIgnoreCase)).Name ??
candidates.FirstOrDefault().Name;
}
public Dictionary<string, Dictionary<string, Dictionary<string, string>>> GetTranslations(
IEnumerable<string> itemIds,
IEnumerable<string> languages)
{
var ids = itemIds.Where(i => !string.IsNullOrWhiteSpace(i)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
var langs = languages.Where(l => !string.IsNullOrWhiteSpace(l)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
var result = new Dictionary<string, Dictionary<string, Dictionary<string, string>>>(StringComparer.OrdinalIgnoreCase);
if (ids.Length == 0 || langs.Length == 0)
return result;
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
var idParams = AddParams(cmd, ids, "$id");
var langParams = AddParams(cmd, langs, "$lang");
cmd.CommandText = $@"
SELECT item_id, lang, field, text
FROM translations
WHERE item_id IN ({idParams}) AND lang IN ({langParams});";
using var reader = cmd.ExecuteReader();
while (reader.Read())
{
var itemId = reader.GetString(0);
var lang = reader.GetString(1);
var field = reader.GetString(2);
var text = reader.GetString(3);
if (!result.TryGetValue(itemId, out var byLang))
{
byLang = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
result[itemId] = byLang;
}
if (!byLang.TryGetValue(lang, out var byField))
{
byField = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
byLang[lang] = byField;
}
byField[field] = text;
}
return result;
}
public Dictionary<string, Dictionary<string, Dictionary<string, string>>> GetAssets(
IEnumerable<string> itemIds,
IEnumerable<string> languages)
{
var ids = itemIds.Where(i => !string.IsNullOrWhiteSpace(i)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
var langs = languages.Where(l => !string.IsNullOrWhiteSpace(l)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
var result = new Dictionary<string, Dictionary<string, Dictionary<string, string>>>(StringComparer.OrdinalIgnoreCase);
if (ids.Length == 0 || langs.Length == 0)
return result;
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
var idParams = AddParams(cmd, ids, "$id");
var langParams = AddParams(cmd, langs, "$asset_lang");
cmd.CommandText = $@"
SELECT item_id, kind, lang, path
FROM assets
WHERE item_id IN ({idParams}) AND lang IN ({langParams});";
using var reader = cmd.ExecuteReader();
while (reader.Read())
{
var itemId = reader.GetString(0);
var kind = reader.GetString(1);
var lang = reader.GetString(2);
var path = reader.GetString(3);
if (!result.TryGetValue(itemId, out var byKind))
{
byKind = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
result[itemId] = byKind;
}
if (!byKind.TryGetValue(kind, out var byLang))
{
byLang = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
byKind[kind] = byLang;
}
byLang[lang] = path;
}
return result;
}
public void SaveUserRules(string userId, UserRulesDocument rules)
{
using var con = Open();
con.Open();
using var tx = con.BeginTransaction();
using (var cmd = con.CreateCommand())
{
cmd.Transaction = tx;
cmd.CommandText = @"
INSERT INTO user_rules(user_id, rules_json, updated_at)
VALUES($user_id, $rules_json, $updated_at)
ON CONFLICT(user_id) DO UPDATE SET rules_json = excluded.rules_json, updated_at = excluded.updated_at;";
cmd.Parameters.AddWithValue("$user_id", userId);
cmd.Parameters.AddWithValue("$rules_json", JsonSerializer.Serialize(rules));
cmd.Parameters.AddWithValue("$updated_at", NowUnixUtc());
cmd.ExecuteNonQuery();
}
using (var cmd = con.CreateCommand())
{
cmd.Transaction = tx;
cmd.CommandText = @"
INSERT INTO user_display_langs(user_id, langs_json, updated_at)
VALUES($user_id, $langs_json, $updated_at)
ON CONFLICT(user_id) DO UPDATE SET langs_json = excluded.langs_json, updated_at = excluded.updated_at;";
cmd.Parameters.AddWithValue("$user_id", userId);
cmd.Parameters.AddWithValue("$langs_json", JsonSerializer.Serialize(rules.FallbackLanguages));
cmd.Parameters.AddWithValue("$updated_at", NowUnixUtc());
cmd.ExecuteNonQuery();
}
tx.Commit();
}
public UserRulesDocument? GetUserRules(string userId)
{
using var con = Open();
con.Open();
using var cmd = con.CreateCommand();
cmd.CommandText = "SELECT rules_json FROM user_rules WHERE user_id = $user_id;";
cmd.Parameters.AddWithValue("$user_id", userId);
var json = cmd.ExecuteScalar() as string;
return string.IsNullOrWhiteSpace(json) ? null : JsonSerializer.Deserialize<UserRulesDocument>(json);
}
private static string AddParams(SqliteCommand cmd, IReadOnlyList<string> values, string prefix)
{
var names = new string[values.Count];
for (var i = 0; i < values.Count; i++)
{
var name = $"{prefix}{i}";
names[i] = name;
cmd.Parameters.AddWithValue(name, values[i]);
}
return string.Join(",", names);
}
}
public readonly record struct FactsStatus(bool Exists, long MissingCheckedAt, long FullCheckedAt);
public readonly record struct GenreRow(int TmdbId, string Media, string Lang, string Name);
public sealed record FactsData(
string ItemId,
string TmdbId,
string Kind,
string OriginalTitle,
string OriginalLanguage,
string OriginalLanguageAll,
string OriginCountriesJson,
string ProductionCountriesJson,
string SpokenLanguagesJson,
string AudioTrackLanguage,
string GenreTmdbIdsJson,
long MissingCheckedAt,
long FullCheckedAt);
public sealed class UserRulesDocument
{
public bool Enabled { get; set; } = true;
public string SortLocale { get; set; } = "Auto";
public string[] FallbackLanguages { get; set; } = [];
public Dictionary<string, string[]> FallbackFieldActions { get; set; } = new(StringComparer.OrdinalIgnoreCase)
{
["title"] = ["Jellyfin"],
["overview"] = ["Jellyfin"],
["tagline"] = ["Jellyfin"],
["poster"] = ["Jellyfin"],
["logo"] = ["Jellyfin"],
["banner"] = ["Jellyfin"],
["thumb"] = ["Jellyfin"],
["backdrop"] = ["Jellyfin"]
};
public bool TrustTmdbCollections { get; set; } = true;
public UserCategoryRule[] Categories { get; set; } = [];
public UserRuleEntry[] Rules { get; set; } = [];
}
public sealed class UserRuleEntry
{
public string Text { get; set; } = string.Empty;
public string[] Languages { get; set; } = [];
public string[] Scopes { get; set; } = [];
}
public sealed class UserCategoryRule
{
public string Id { get; set; } = Guid.NewGuid().ToString("N");
public string Label { get; set; } = string.Empty;
public string CriteriaText { get; set; } = string.Empty;
public UserCategoryRequirement[] Requirements { get; set; } = [];
public bool MatchAllConditions { get; set; } = true;
public string[] Scopes { get; set; } = ["M", "S", "C"];
public Dictionary<string, string> FieldActions { get; set; } = new(StringComparer.OrdinalIgnoreCase)
{
["title"] = "Fallback",
["overview"] = "Fallback",
["tagline"] = "Fallback",
["poster"] = "Fallback",
["logo"] = "Fallback",
["banner"] = "Fallback",
["thumb"] = "Fallback",
["backdrop"] = "Fallback"
};
public Dictionary<string, string[]> FieldActionLists { get; set; } = new(StringComparer.OrdinalIgnoreCase)
{
["title"] = ["Jellyfin"],
["overview"] = ["Jellyfin"],
["tagline"] = ["Jellyfin"],
["poster"] = ["Jellyfin"],
["logo"] = ["Jellyfin"],
["banner"] = ["Jellyfin"],
["thumb"] = ["Jellyfin"],
["backdrop"] = ["Jellyfin"]
};
}
public sealed class UserCategoryRequirement
{
public string Field { get; set; } = string.Empty;
public string[] Fields { get; set; } = [];
public bool UseFieldOr { get; set; }
public string Relation { get; set; } = string.Empty;
public bool UseOr { get; set; }
public string[] Values { get; set; } = [];
}