Remove obsolete rule formats, batch SQLite work, preserve artwork source URLs, and coordinate refresh workers with maintenance. Add regression coverage and document backup format changes.
167 lines
6.8 KiB
C#
167 lines
6.8 KiB
C#
using Jellyfin.Plugin.Multilang.Data;
|
|
using static Jellyfin.Plugin.Multilang.MultilangConstants;
|
|
|
|
namespace Jellyfin.Plugin.Multilang.Rules;
|
|
|
|
public static class UserRulesNormalizer
|
|
{
|
|
private static readonly string[] RequirementFieldOrder =
|
|
[
|
|
"original_language",
|
|
"spoken_languages",
|
|
"audio_language",
|
|
"origin_countries",
|
|
"production_countries"
|
|
];
|
|
|
|
public static UserRulesDocument Normalize(UserRulesDocument rules, IEnumerable<string>? languages = null)
|
|
{
|
|
var allowed = (languages ?? (rules.Categories ?? []).SelectMany(c => (c.FieldActionLists ?? []).Values)
|
|
.Concat((rules.FallbackFieldActions ?? []).Values).SelectMany(actions => actions ?? [])
|
|
.Where(action => action is not null && action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase)).Select(action => action[LanguagePrefix.Length..]))
|
|
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
rules.Categories = NormalizeCategories(rules.Categories, allowed);
|
|
rules.FallbackFieldActions = NormalizeActionLists(rules.FallbackFieldActions, allowed);
|
|
return rules;
|
|
}
|
|
|
|
private static UserCategoryRule[] NormalizeCategories(IEnumerable<UserCategoryRule>? categories, IReadOnlySet<string> allowedLanguages)
|
|
=> (categories ?? [])
|
|
.Select(category => new UserCategoryRule
|
|
{
|
|
Id = string.IsNullOrWhiteSpace(category.Id) ? Guid.NewGuid().ToString("N") : category.Id.Trim(),
|
|
Label = string.IsNullOrWhiteSpace(category.Label) ? "Category" : category.Label.Trim(),
|
|
Requirements = NormalizeRequirements(category.Requirements),
|
|
MatchAllConditions = category.MatchAllConditions,
|
|
Scopes = (category.Scopes ?? [])
|
|
.Where(scope => scope is "M" or "S" or "C")
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.DefaultIfEmpty("M")
|
|
.ToArray(),
|
|
FieldActionLists = NormalizeActionLists(category.FieldActionLists, allowedLanguages)
|
|
})
|
|
.ToArray();
|
|
|
|
private static UserCategoryRequirement[] NormalizeRequirements(IEnumerable<UserCategoryRequirement>? requirements)
|
|
=> (requirements ?? [])
|
|
.Select(requirement =>
|
|
{
|
|
var fields = NormalizeRequirementFields(requirement.Fields);
|
|
return new UserCategoryRequirement
|
|
{
|
|
Fields = fields,
|
|
UseFieldOr = requirement.UseFieldOr,
|
|
Relation = NormalizeRequirementRelation(requirement.Relation),
|
|
UseOr = requirement.UseOr,
|
|
Values = (requirement.Values ?? [])
|
|
.Where(v => !string.IsNullOrWhiteSpace(v))
|
|
.Select(v => v.Trim())
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.ToArray()
|
|
};
|
|
})
|
|
.Where(requirement =>
|
|
requirement.Fields.Length > 0 &&
|
|
requirement.Relation.Length > 0 &&
|
|
requirement.Values.Length > 0)
|
|
.ToArray();
|
|
|
|
private static string[] NormalizeRequirementFields(IEnumerable<string>? fields)
|
|
{
|
|
var requested = (fields ?? [])
|
|
.Select(NormalizeRequirementField)
|
|
.Where(field => field.Length > 0)
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
|
|
var result = new List<string>();
|
|
string? kind = null;
|
|
foreach (var field in RequirementFieldOrder)
|
|
{
|
|
if (!requested.Contains(field))
|
|
continue;
|
|
|
|
var currentKind = IsCountryRequirementField(field) ? "country" : "language";
|
|
kind ??= currentKind;
|
|
if (currentKind == kind)
|
|
result.Add(field);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private static string NormalizeRequirementField(string? field)
|
|
{
|
|
var normalized = (field ?? string.Empty).Trim().ToLowerInvariant();
|
|
return normalized is "original_language" or "spoken_languages" or "audio_language" or "origin_countries" or "production_countries"
|
|
? normalized
|
|
: string.Empty;
|
|
}
|
|
|
|
private static bool IsCountryRequirementField(string field)
|
|
=> field.Equals("origin_countries", StringComparison.OrdinalIgnoreCase) ||
|
|
field.Equals("production_countries", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static string NormalizeRequirementRelation(string? relation)
|
|
{
|
|
var normalized = (relation ?? string.Empty).Trim().ToLowerInvariant();
|
|
return normalized is "is" or "is_not" or "contains" or "not_contains"
|
|
? normalized
|
|
: string.Empty;
|
|
}
|
|
|
|
private static Dictionary<string, string[]> NormalizeActionLists(
|
|
IReadOnlyDictionary<string, string[]>? actions,
|
|
IReadOnlySet<string> allowedLanguages)
|
|
{
|
|
var result = DefaultActionLists();
|
|
foreach (var field in result.Keys.ToArray())
|
|
{
|
|
var raw = actions is not null && actions.TryGetValue(field, out var configured)
|
|
? configured
|
|
: [JellyfinAction];
|
|
result[field] = NormalizeActionList(field, raw, allowedLanguages);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static string[] NormalizeActionList(string field, IEnumerable<string>? raw, IReadOnlySet<string> allowedLanguages)
|
|
{
|
|
var result = new List<string>();
|
|
foreach (var action in raw ?? [])
|
|
{
|
|
var normalized = NormalizeActionToken(action, allowedLanguages);
|
|
if (normalized.Length == 0)
|
|
continue;
|
|
if (result.Contains(normalized, StringComparer.OrdinalIgnoreCase))
|
|
continue;
|
|
result.Add(normalized);
|
|
}
|
|
|
|
if (RequiresJellyfinFallback(field))
|
|
{
|
|
if (!result.Contains(JellyfinAction, StringComparer.OrdinalIgnoreCase))
|
|
result.Add(JellyfinAction);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private static string NormalizeActionToken(string? raw, IReadOnlySet<string> allowedLanguages)
|
|
{
|
|
var action = (raw ?? string.Empty).Trim();
|
|
if (action.Equals(JellyfinAction, StringComparison.OrdinalIgnoreCase))
|
|
return JellyfinAction;
|
|
if (action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase))
|
|
return OriginalAction;
|
|
|
|
var lang = action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase)
|
|
? action[LanguagePrefix.Length..].Trim()
|
|
: string.Empty;
|
|
var canonical = allowedLanguages.FirstOrDefault(l => l.Equals(lang, StringComparison.OrdinalIgnoreCase));
|
|
return string.IsNullOrWhiteSpace(canonical) ? string.Empty : LanguagePrefix + canonical;
|
|
}
|
|
|
|
}
|