Florian Schmidt
bfa0b537ee
ci / build-test (push) Failing after 35s
The last open item on the M7 list. Number and currency formatting was already locale-aware, but every string in the UI was an English literal, so a German instance read half in each language -- German data, English chrome. This translates all of it and adds the machinery to keep it translated. Strings live in Localization/Strings.resx (English, neutral) and Strings.de.resx. The neutral file generates a strongly-typed accessor at build time, aliased as S in _Imports.razor, so components reference compiled properties -- @S.Common_Save, not a string key. That choice is the point: across 4,500 lines of markup, a key lookup that silently falls back to its own name is a defect you find in production, while a renamed property is a build error. Generation runs in MSBuild rather than the IDE designer, so dotnet build alone reproduces it anywhere. Resource fallback is the hazard here. Ask for a key the German satellite lacks and ResourceManager quietly serves the English one -- correct at runtime, disastrous at release time, because a half-translated build looks perfectly healthy. StringResourceTests reads each satellite with tryParents: false, which is the only way to see what one actually contains, and fails on a missing or blank translation, a placeholder that changed arity, an orphan, or a key nothing references. Three things needed more than substitution: - Domain enums reached the screen as bare identifiers. They stay bare in the model -- they are persisted as text and appear in the REST API, so their names are part of the data contract -- and DisplayNames is now the single place that decides how each value is spoken. Every arm ends in a fallback returning the identifier, so a value added later cannot throw mid-render; EnumDisplayNameTests is what stops that safety net quietly becoming the shipping behaviour. - Infrastructure was writing display text: FlowService's "Other (X)", MeterPeriodView's "Generation"/"Consumption", the HA connection-test verdicts, the updater's snackbar, the CSV importer's row warnings. Each now returns an outcome value and the UI supplies the words, which is where the reader's language is known. Diagnostics that are not ours -- an HTTP status, systemd's stderr, an exception message -- are passed through untranslated, and every English summary is kept alongside the outcome so log lines never move with the UI language. The UpdateRunner change is additive only; no gate was touched. - Importer warnings carry their arguments rather than a finished sentence, so the numbers inside them pick up the reader's grouping. A register that reads 2.940,19 everywhere else must not read 2940.19 only inside a warning. Switching language is a redirect through /culture/set followed by a full reload, not an interactive state change: a Blazor Server circuit is fixed to the culture of the request that opened it. That makes the endpoint a redirector taking its target from the query string, so anything but a local path is refused rather than followed. Preference order is the cookie, then Accept-Language, then MeterVault__Locale -- an instance can be pinned to one language and a reader can still switch. Locale keeps its documented default of "en". Format now follows CurrentCulture instead of a hardcoded de-DE, so an instance with nothing configured and a browser asking for English will show English number formatting where it previously showed German; set MeterVault__Locale=de to pin the old behaviour. The importer's de-DE parsing is untouched and stays that way -- that dialect is a property of the spreadsheets, not of whoever is looking at the dashboard. Anything that comes from the database -- meter names, energy-type display names, category names -- is user data and is never translated. Claude-Session: https://claude.ai/code/session_0112ezeWqaZ85kTj5bYu9JHx
65 lines
2.6 KiB
C#
65 lines
2.6 KiB
C#
using System.Globalization;
|
|
|
|
namespace MeterVault.App.Localization;
|
|
|
|
/// <summary>
|
|
/// UI-language plumbing around <see cref="Strings"/>, the strongly-typed accessor MSBuild generates
|
|
/// from <c>Strings.resx</c> (see the <c>EmbeddedResource</c> block in the project file).
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The neutral resource is English and every other language ships as a satellite assembly, so an
|
|
/// <c>Accept-Language</c> we don't translate degrades to English rather than to raw resource keys.
|
|
/// Strings are referenced as compiled properties (<c>S.Common_Save</c>), not string lookups, so a
|
|
/// key that no longer exists is a build error instead of a mystery label at runtime.
|
|
/// </para>
|
|
/// <para>
|
|
/// Number and date <em>formatting</em> follows <see cref="CultureInfo.CurrentCulture"/> and the UI
|
|
/// language follows <see cref="CultureInfo.CurrentUICulture"/>; the request-localization middleware
|
|
/// sets both from the same choice, so the two never disagree.
|
|
/// </para>
|
|
/// </remarks>
|
|
public static class Loc
|
|
{
|
|
/// <summary>Cultures the UI ships translations for. The first entry is the neutral fallback.</summary>
|
|
public static IReadOnlyList<string> SupportedCultures { get; } = ["en", "de"];
|
|
|
|
/// <summary>Formats a resource carrying <c>{0}</c>-style placeholders in the request's culture.</summary>
|
|
public static string F(string format, params object?[] args) =>
|
|
string.Format(CultureInfo.CurrentCulture, format, args);
|
|
|
|
/// <summary>
|
|
/// Maps a requested language onto one we actually ship, matching on the two-letter tag so
|
|
/// <c>de-AT</c> and <c>de-CH</c> get German instead of falling through to English.
|
|
/// </summary>
|
|
/// <returns><c>true</c> when the request named a language we translate.</returns>
|
|
public static bool TryResolve(string? requested, out string resolved)
|
|
{
|
|
resolved = SupportedCultures[0];
|
|
|
|
if (string.IsNullOrWhiteSpace(requested))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var trimmed = requested.Trim();
|
|
var separator = trimmed.IndexOfAny(['-', '_']);
|
|
var language = separator < 0 ? trimmed : trimmed[..separator];
|
|
|
|
foreach (var supported in SupportedCultures)
|
|
{
|
|
if (string.Equals(supported, language, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
resolved = supported;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>The display name of a supported culture, written in that language ("Deutsch", "English").</summary>
|
|
public static string DisplayName(string culture) =>
|
|
CultureInfo.GetCultureInfo(culture).NativeName;
|
|
}
|