-
MeterVault @latest is available — this instance runs @running.
+
@((MarkupString)Loc.F(S.UpdateBanner_ReleaseAvailable, Bold(latest), Bold(running)))
@if (Runner.Availability is UpdateAvailability.Allowed)
{
- Update now
+ @S.UpdateBanner_UpdateNow
}
else
@@ -29,17 +30,16 @@
}
- Update MeterVault
+ @S.UpdateBanner_DialogTitle
- This pulls the latest source, rebuilds it, and restarts the service. It takes a few minutes,
- during which MeterVault is unavailable. Readings are not affected — ingestion resumes on restart.
+ @S.UpdateBanner_DialogBody
- Cancel
+ @S.Common_Cancel
- @(_starting ? "Starting…" : "Update now")
+ @(_starting ? S.UpdateBanner_Starting : S.UpdateBanner_UpdateNow)
@@ -80,7 +80,7 @@
try
{
var launch = await Runner.LaunchAsync();
- Snackbar.Add(launch.Message, launch.Started ? Severity.Success : Severity.Error);
+ Snackbar.Add(OutcomeText(launch), launch.Started ? Severity.Success : Severity.Error);
if (launch.Started)
{
_confirmOpen = false;
@@ -92,6 +92,24 @@
}
}
+ // UpdateLaunch.Message stays English for the log; the reader gets the outcome in their own
+ // language, with the launcher's own diagnostic text appended untranslated — it comes from
+ // systemd, not from us, and mangling it would make it unsearchable.
+ private static string OutcomeText(UpdateLaunch launch) => launch.Outcome switch
+ {
+ UpdateOutcome.Started => S.Update_LaunchStarted,
+ UpdateOutcome.NotAllowed => Loc.F(
+ S.Update_LaunchNotAllowed,
+ launch.Availability?.Display() ?? string.Empty),
+ UpdateOutcome.LauncherMissing => S.Update_LaunchLauncherMissing,
+ UpdateOutcome.LauncherFailed => launch.Detail is { Length: > 0 } detail
+ ? Loc.F(S.Update_LaunchFailedWithDetail, detail)
+ : S.Update_LaunchFailed,
+ _ => launch.Detail is { Length: > 0 } error
+ ? Loc.F(S.Update_LaunchFailedWithDetail, error)
+ : S.Update_LaunchFailed,
+ };
+
///
/// How this particular install updates. The LXC has an update command; a container is
/// replaced by pulling a new image, and telling those users to run update would send them
@@ -99,6 +117,9 @@
///
private static string UpdateCommandHint() =>
UpdateRunner.IsSupportedHere
- ? "run: update"
- : "pull the new image and recreate the container";
+ ? S.UpdateBanner_HintRunUpdate
+ : S.UpdateBanner_HintPullImage;
+
+ ///
Emphasises a version inside the banner sentence without letting it carry markup.
+ private static string Bold(object value) => $"
{WebUtility.HtmlEncode(value.ToString())}";
}
diff --git a/src/App/Components/_Imports.razor b/src/App/Components/_Imports.razor
index ff95347..73e3eb8 100644
--- a/src/App/Components/_Imports.razor
+++ b/src/App/Components/_Imports.razor
@@ -8,6 +8,10 @@
@using Microsoft.JSInterop
@using MudBlazor
@using MeterVault.App
+@using MeterVault.App.Localization
+@* UI strings live in Localization/Strings.resx and are reached through this alias: @S.Common_Save.
+ Compiled properties, so a stale key fails the build. @Loc.F(...) formats the {0} ones. *@
+@using S = MeterVault.App.Localization.Strings
@using MeterVault.App.Components
@using MeterVault.App.Components.Layout
@using MeterVault.App.Components.Shared
diff --git a/src/App/Confirm.cs b/src/App/Confirm.cs
index 3d5fcd2..79e6a28 100644
--- a/src/App/Confirm.cs
+++ b/src/App/Confirm.cs
@@ -1,3 +1,4 @@
+using MeterVault.App.Localization;
using MudBlazor;
namespace MeterVault.App;
@@ -7,7 +8,7 @@ public static class Confirm
{
public static async Task
DeleteAsync(IDialogService dialog, string title, string message)
{
- var result = await dialog.ShowMessageBoxAsync(title, message, yesText: "Delete", cancelText: "Cancel")
+ var result = await dialog.ShowMessageBoxAsync(title, message, yesText: Strings.Common_Delete, cancelText: Strings.Common_Cancel)
.ConfigureAwait(false);
return result == true;
}
@@ -15,7 +16,7 @@ public static class Confirm
/// A generic yes/cancel confirmation with a caller-supplied confirm-button label.
public static async Task ConfirmAsync(IDialogService dialog, string title, string message, string confirmText)
{
- var result = await dialog.ShowMessageBoxAsync(title, message, yesText: confirmText, cancelText: "Cancel")
+ var result = await dialog.ShowMessageBoxAsync(title, message, yesText: confirmText, cancelText: Strings.Common_Cancel)
.ConfigureAwait(false);
return result == true;
}
diff --git a/src/App/Format.cs b/src/App/Format.cs
index 5c60083..4ae3528 100644
--- a/src/App/Format.cs
+++ b/src/App/Format.cs
@@ -2,18 +2,35 @@ using System.Globalization;
namespace MeterVault.App;
-/// Small display formatters for the UI (locale-aware formatting arrives with i18n in M7).
+///
+/// Small display formatters for the UI.
+///
+///
+/// Everything formats against , which the request
+/// localization middleware sets from the reader's chosen UI language — so 1234.5 renders as
+/// "1.234,5" for a German reader and "1,234.5" for an English one, from the same call site. This is
+/// display only: the CSV importer still parses the spreadsheet dialect with an explicit de-DE
+/// culture (), because that dialect is a property of the
+/// files, not of who is looking at them.
+///
public static class Format
{
- private static readonly CultureInfo Culture = CultureInfo.GetCultureInfo("de-DE");
-
- public static string Euro(double value) => value.ToString("N2", Culture) + " €";
+ ///
+ /// A money amount. The symbol is the euro rather than the culture's own, because the figure is
+ /// in the instance's configured currency — switching UI language must not restate the amount as
+ /// dollars. Only the digit grouping follows the reader.
+ ///
+ public static string Euro(double value) => value.ToString("N2", CultureInfo.CurrentCulture) + " €";
public static string Number(double value, int decimals = 0) =>
- value.ToString("N" + decimals.ToString(CultureInfo.InvariantCulture), Culture);
+ value.ToString("N" + decimals.ToString(CultureInfo.InvariantCulture), CultureInfo.CurrentCulture);
public static string Percent(double value) =>
- (value >= 0 ? "+" : "") + value.ToString("N1", Culture) + " %";
+ (value >= 0 ? "+" : "") + value.ToString("N1", CultureInfo.CurrentCulture) + " %";
+
+ /// A month label for chart axes and period lists ("Mrz 25" / "Mar 25").
+ public static string MonthLabel(DateOnly month) =>
+ month.ToString("MMM yy", CultureInfo.CurrentCulture);
public static string DirectionIcon(int direction) => direction switch
{
diff --git a/src/App/Localization/CultureEndpoints.cs b/src/App/Localization/CultureEndpoints.cs
new file mode 100644
index 0000000..2bc381f
--- /dev/null
+++ b/src/App/Localization/CultureEndpoints.cs
@@ -0,0 +1,63 @@
+using Microsoft.AspNetCore.Localization;
+
+namespace MeterVault.App.Localization;
+
+/// The endpoint behind the language picker in the app bar.
+public static class CultureEndpoints
+{
+ ///
+ /// Persists a UI language and returns the user to where they were.
+ ///
+ ///
+ /// A redirect rather than an interactive state change on purpose: a Blazor Server circuit
+ /// captures from the request
+ /// that opened it, so switching language has to re-establish the circuit. The picker therefore
+ /// navigates here with forceLoad, this writes the culture cookie the localization
+ /// middleware reads, and the reload comes back in the new language.
+ ///
+ public static IEndpointRouteBuilder MapCultureEndpoints(this IEndpointRouteBuilder endpoints)
+ {
+ ArgumentNullException.ThrowIfNull(endpoints);
+
+ endpoints.MapGet("/culture/set", (HttpContext http, string? culture, string? redirectUri) =>
+ {
+ // Only ever store a language we ship, so a hand-edited link can't park an unusable
+ // culture in the cookie and leave the UI stuck in fallback.
+ if (!Loc.TryResolve(culture, out var resolved))
+ {
+ return Results.BadRequest($"Unsupported culture '{culture}'.");
+ }
+
+ http.Response.Cookies.Append(
+ CookieRequestCultureProvider.DefaultCookieName,
+ CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(resolved)),
+ new CookieOptions
+ {
+ Path = "/",
+ Expires = DateTimeOffset.UtcNow.AddYears(1),
+ SameSite = SameSiteMode.Lax,
+ // Read only by the localization middleware, never by script.
+ HttpOnly = true,
+ // A language preference is exempt from consent gating, and the app is
+ // self-hosted and single-user anyway.
+ IsEssential = true,
+ });
+
+ // Anything but a local path is refused rather than followed: this endpoint takes a
+ // redirect target from the query string, which is exactly the shape of an open redirect.
+ return Results.LocalRedirect(IsLocalPath(redirectUri) ? redirectUri! : "/");
+ })
+ .ExcludeFromDescription();
+
+ return endpoints;
+ }
+
+ ///
+ /// The framework's own local-URL rule: rooted, and not the "//host" or "/\host" forms browsers
+ /// resolve as protocol-relative absolute URLs.
+ ///
+ private static bool IsLocalPath(string? url) =>
+ !string.IsNullOrEmpty(url)
+ && url[0] == '/'
+ && (url.Length == 1 || (url[1] != '/' && url[1] != '\\'));
+}
diff --git a/src/App/Localization/DisplayNames.cs b/src/App/Localization/DisplayNames.cs
new file mode 100644
index 0000000..e894853
--- /dev/null
+++ b/src/App/Localization/DisplayNames.cs
@@ -0,0 +1,188 @@
+using MeterVault.Core.Domain;
+using MeterVault.Infrastructure.Import;
+using MeterVault.Infrastructure.Update;
+
+namespace MeterVault.App.Localization;
+
+///
+/// Human wording for the domain enums the UI puts on screen.
+///
+///
+///
+/// The enums themselves stay bare identifiers: they are persisted as text (SDD §5.2) and appear in
+/// the REST API, so their names are part of the data contract and must not move with the reader's
+/// language. This is the one place that decides how each value is spoken, which keeps the
+/// domain layer free of presentation and gives every page the same word for the same concept —
+/// a TariffComponent.UnitPrice is "Arbeitspreis" in the table, the dropdown and the
+/// confirm dialog alike.
+///
+///
+/// Every arm resolves a Enum_<Type>_<Value> resource. The fallback arms return the
+/// identifier rather than throwing, so adding an enum value can never crash a dashboard — and
+/// EnumDisplayNameTests fails the build if one is ever left without a translation, which is
+/// what stops that safety net from quietly becoming the shipping behaviour.
+///
+///
+public static class DisplayNames
+{
+ /// The enums this class is responsible for; the resource-coverage test walks this list.
+ public static IReadOnlyList LocalizedEnums { get; } =
+ [
+ typeof(MeterMode),
+ typeof(ConsumptionKind),
+ typeof(ReadingQuality),
+ typeof(ReadingFlags),
+ typeof(MeterEventType),
+ typeof(SourceType),
+ typeof(SourceValueKind),
+ typeof(TariffScope),
+ typeof(TariffComponent),
+ typeof(TankRateMode),
+ typeof(EndpointType),
+ typeof(MappingRole),
+ typeof(UpdateAvailability),
+ ];
+
+ public static string Display(this MeterMode value) => value switch
+ {
+ MeterMode.CumulativeCounter => Strings.Enum_MeterMode_CumulativeCounter,
+ MeterMode.GenerationCounter => Strings.Enum_MeterMode_GenerationCounter,
+ MeterMode.RuntimeCounter => Strings.Enum_MeterMode_RuntimeCounter,
+ MeterMode.ConsumableBalance => Strings.Enum_MeterMode_ConsumableBalance,
+ MeterMode.DirectDelta => Strings.Enum_MeterMode_DirectDelta,
+ MeterMode.InstantRate => Strings.Enum_MeterMode_InstantRate,
+ MeterMode.Virtual => Strings.Enum_MeterMode_Virtual,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this ConsumptionKind value) => value switch
+ {
+ ConsumptionKind.Consumption => Strings.Enum_ConsumptionKind_Consumption,
+ ConsumptionKind.Generation => Strings.Enum_ConsumptionKind_Generation,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this ReadingQuality value) => value switch
+ {
+ ReadingQuality.Measured => Strings.Enum_ReadingQuality_Measured,
+ ReadingQuality.Estimated => Strings.Enum_ReadingQuality_Estimated,
+ ReadingQuality.Manual => Strings.Enum_ReadingQuality_Manual,
+ ReadingQuality.Imported => Strings.Enum_ReadingQuality_Imported,
+ ReadingQuality.Interpolated => Strings.Enum_ReadingQuality_Interpolated,
+ _ => value.ToString(),
+ };
+
+ ///
+ /// A bitmask rendered as the set flags, comma-joined. gives an
+ /// empty string: the readings table shows a flag column that is blank for almost every row, and
+ /// printing "None" a thousand times down a page is noise, not information.
+ ///
+ public static string Display(this ReadingFlags value)
+ {
+ if (value == ReadingFlags.None)
+ {
+ return string.Empty;
+ }
+
+ var names = new List(3);
+ if (value.HasFlag(ReadingFlags.CounterReset))
+ {
+ names.Add(Strings.Enum_ReadingFlags_CounterReset);
+ }
+
+ if (value.HasFlag(ReadingFlags.MeterSwap))
+ {
+ names.Add(Strings.Enum_ReadingFlags_MeterSwap);
+ }
+
+ if (value.HasFlag(ReadingFlags.Anomaly))
+ {
+ names.Add(Strings.Enum_ReadingFlags_Anomaly);
+ }
+
+ return names.Count > 0 ? string.Join(", ", names) : value.ToString();
+ }
+
+ public static string Display(this MeterEventType value) => value switch
+ {
+ MeterEventType.MeterSwap => Strings.Enum_MeterEventType_MeterSwap,
+ MeterEventType.CounterReset => Strings.Enum_MeterEventType_CounterReset,
+ MeterEventType.Delivery => Strings.Enum_MeterEventType_Delivery,
+ MeterEventType.TankLevel => Strings.Enum_MeterEventType_TankLevel,
+ MeterEventType.Correction => Strings.Enum_MeterEventType_Correction,
+ MeterEventType.Note => Strings.Enum_MeterEventType_Note,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this SourceType value) => value switch
+ {
+ SourceType.Mqtt => Strings.Enum_SourceType_Mqtt,
+ SourceType.Tasmota => Strings.Enum_SourceType_Tasmota,
+ SourceType.HomeAssistant => Strings.Enum_SourceType_HomeAssistant,
+ SourceType.Manual => Strings.Enum_SourceType_Manual,
+ SourceType.Import => Strings.Enum_SourceType_Import,
+ SourceType.Virtual => Strings.Enum_SourceType_Virtual,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this SourceValueKind value) => value switch
+ {
+ SourceValueKind.Register => Strings.Enum_SourceValueKind_Register,
+ SourceValueKind.Delta => Strings.Enum_SourceValueKind_Delta,
+ SourceValueKind.Rate => Strings.Enum_SourceValueKind_Rate,
+ SourceValueKind.Level => Strings.Enum_SourceValueKind_Level,
+ SourceValueKind.Runtime => Strings.Enum_SourceValueKind_Runtime,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this TariffScope value) => value switch
+ {
+ TariffScope.Global => Strings.Enum_TariffScope_Global,
+ TariffScope.EnergyType => Strings.Enum_TariffScope_EnergyType,
+ TariffScope.Meter => Strings.Enum_TariffScope_Meter,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this TariffComponent value) => value switch
+ {
+ TariffComponent.UnitPrice => Strings.Enum_TariffComponent_UnitPrice,
+ TariffComponent.BasePrice => Strings.Enum_TariffComponent_BasePrice,
+ TariffComponent.FeedIn => Strings.Enum_TariffComponent_FeedIn,
+ TariffComponent.Bonus => Strings.Enum_TariffComponent_Bonus,
+ TariffComponent.Discount => Strings.Enum_TariffComponent_Discount,
+ TariffComponent.Tax => Strings.Enum_TariffComponent_Tax,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this TankRateMode value) => value switch
+ {
+ TankRateMode.Fixed => Strings.Enum_TankRateMode_Fixed,
+ TankRateMode.Empirical => Strings.Enum_TankRateMode_Empirical,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this EndpointType value) => value switch
+ {
+ EndpointType.MqttBroker => Strings.Enum_EndpointType_MqttBroker,
+ EndpointType.HomeAssistant => Strings.Enum_EndpointType_HomeAssistant,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this UpdateAvailability value) => value switch
+ {
+ UpdateAvailability.Allowed => Strings.Enum_UpdateAvailability_Allowed,
+ UpdateAvailability.NotEnabled => Strings.Enum_UpdateAvailability_NotEnabled,
+ UpdateAvailability.NotSupportedHere => Strings.Enum_UpdateAvailability_NotSupportedHere,
+ _ => value.ToString(),
+ };
+
+ public static string Display(this MappingRole value) => value switch
+ {
+ MappingRole.Ignore => Strings.Enum_MappingRole_Ignore,
+ MappingRole.Reading => Strings.Enum_MappingRole_Reading,
+ MappingRole.Delivery => Strings.Enum_MappingRole_Delivery,
+ MappingRole.TankLevel => Strings.Enum_MappingRole_TankLevel,
+ MappingRole.ManualCost => Strings.Enum_MappingRole_ManualCost,
+ _ => value.ToString(),
+ };
+}
diff --git a/src/App/Localization/ImportWarningText.cs b/src/App/Localization/ImportWarningText.cs
new file mode 100644
index 0000000..84b07ba
--- /dev/null
+++ b/src/App/Localization/ImportWarningText.cs
@@ -0,0 +1,36 @@
+using MeterVault.Infrastructure.Import;
+
+namespace MeterVault.App.Localization;
+
+///
+/// Says a staging warning in the reader's language.
+///
+///
+/// The importer emits values carrying an English sentence plus the
+/// arguments that filled it (see ImportWarnings). Re-formatting from the arguments rather
+/// than translating the finished sentence is what lets the numbers pick up the reader's digit
+/// grouping — a register that reads 2.940,19 everywhere else must not read 2940.19
+/// only inside a warning.
+///
+public static class ImportWarningText
+{
+ public static string Display(this ImportWarning warning)
+ {
+ ArgumentNullException.ThrowIfNull(warning);
+
+ var args = warning.Args as object?[] ?? [.. warning.Args];
+
+ return warning.Kind switch
+ {
+ ImportWarningKind.RowSkipped => Loc.F(Strings.ImportWarning_RowSkipped, args),
+ ImportWarningKind.UnparseableDate => Loc.F(Strings.ImportWarning_UnparseableDate, args),
+ ImportWarningKind.UnitMismatch => Loc.F(Strings.ImportWarning_UnitMismatch, args),
+ ImportWarningKind.RegisterDropped => Loc.F(Strings.ImportWarning_RegisterDropped, args),
+ ImportWarningKind.RegisterDroppedWithAmount =>
+ Loc.F(Strings.ImportWarning_RegisterDroppedWithAmount, args),
+
+ // A kind added later still says something useful rather than blanking the panel.
+ _ => warning.Message,
+ };
+ }
+}
diff --git a/src/App/Localization/Loc.cs b/src/App/Localization/Loc.cs
new file mode 100644
index 0000000..ffb2e5f
--- /dev/null
+++ b/src/App/Localization/Loc.cs
@@ -0,0 +1,64 @@
+using System.Globalization;
+
+namespace MeterVault.App.Localization;
+
+///
+/// UI-language plumbing around , the strongly-typed accessor MSBuild generates
+/// from Strings.resx (see the EmbeddedResource block in the project file).
+///
+///
+///
+/// The neutral resource is English and every other language ships as a satellite assembly, so an
+/// Accept-Language we don't translate degrades to English rather than to raw resource keys.
+/// Strings are referenced as compiled properties (S.Common_Save), not string lookups, so a
+/// key that no longer exists is a build error instead of a mystery label at runtime.
+///
+///
+/// Number and date formatting follows and the UI
+/// language follows ; the request-localization middleware
+/// sets both from the same choice, so the two never disagree.
+///
+///
+public static class Loc
+{
+ /// Cultures the UI ships translations for. The first entry is the neutral fallback.
+ public static IReadOnlyList SupportedCultures { get; } = ["en", "de"];
+
+ /// Formats a resource carrying {0}-style placeholders in the request's culture.
+ public static string F(string format, params object?[] args) =>
+ string.Format(CultureInfo.CurrentCulture, format, args);
+
+ ///
+ /// Maps a requested language onto one we actually ship, matching on the two-letter tag so
+ /// de-AT and de-CH get German instead of falling through to English.
+ ///
+ /// true when the request named a language we translate.
+ 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;
+ }
+
+ /// The display name of a supported culture, written in that language ("Deutsch", "English").
+ public static string DisplayName(string culture) =>
+ CultureInfo.GetCultureInfo(culture).NativeName;
+}
diff --git a/src/App/Localization/Strings.de.resx b/src/App/Localization/Strings.de.resx
new file mode 100644
index 0000000..ce99752
--- /dev/null
+++ b/src/App/Localization/Strings.de.resx
@@ -0,0 +1,1635 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ Hinzufügen
+
+
+ Kategorie hinzufügen
+
+
+ Energieart hinzufügen
+
+
+ Zähler hinzufügen
+
+
+ Schließen
+
+
+ Farbe als Hex-Wert (optional, z. B. #ff9800)
+
+
+ '{0}' und die {1} Zuordnung(en) löschen? Manuelle Kosten dieser Kategorie bleiben erhalten, verlieren aber die Zuordnung.
+
+
+ Kategorie löschen
+
+
+ {0} bearbeiten
+
+
+ Zähler: {0}
+
+
+ {0} Zähler, {1} Energieart(en)
+
+
+ Energieart: {0}
+
+
+ Zuordnungen
+
+
+ Neue Kategorie
+
+
+ Noch keine Mitglieder — Zähler oder Energieart hinzufügen.
+
+
+ Kategorie zuerst speichern, um Mitglieder hinzuzufügen.
+
+
+ Gespeichert. Mitglieder unten hinzufügen.
+
+
+ Sortierung
+
+
+ Sortierreihenfolge
+
+
+ Kosten
+
+
+ Aktionen
+
+
+ Menge
+
+
+ Abbrechen
+
+
+ Kosten (Zeitraum)
+
+
+ Währung
+
+
+ Datum
+
+
+ Löschen
+
+
+ Gelöscht.
+
+
+ Aktiviert
+
+
+ Energieart
+
+
+ Ereignisse:
+
+
+ Zuletzt gesehen
+
+
+ Manuelle Kosten:
+
+
+ Zähler
+
+
+ Zähler
+
+
+ Modus
+
+
+ Name
+
+
+ Name ist erforderlich.
+
+
+ Keine Daten in diesem Zeitraum.
+
+
+ Jetzt
+
+
+ Vorschau
+
+
+ Zeitraum
+
+
+ Gesamter Zeitraum
+
+
+ Letzte 12 Monate
+
+
+ Letzte 24 Monate
+
+
+ Letzte 5 Jahre
+
+
+ Zählerstände:
+
+
+ Speichern
+
+
+ Gespeichert.
+
+
+ Geltungsbereich
+
+
+ Übersprungene Zeilen:
+
+
+ Status
+
+
+ Ziel
+
+
+ Dieses Jahr
+
+
+ Typ
+
+
+ Einheit
+
+
+ Wert
+
+
+ Konnektor hinzufügen
+
+
+ Basis-URL (z. B. http://homeassistant.local:8123)
+
+
+ „{0}“ löschen?
+
+
+ {0} Quelle(n) nutzen ihn und erfassen keine Daten mehr, bis sie einem anderen Konnektor zugeordnet sind.
+
+
+ Konnektor löschen
+
+
+ {0} bearbeiten
+
+
+ Noch keine Konnektoren. MQTT-Broker oder Home-Assistant-Verbindung hinzufügen.
+
+
+ Wird vor dem Speichern verschlüsselt; Datenbank-Dumps und JSON-Exporte enthalten nichts Verwertbares.
+
+
+ Zugangsdaten hier eingeben
+
+
+ Token hier eingeben
+
+
+ Zusätzliche Topics (kommagetrennt, optional)
+
+
+ Host
+
+
+ Letzter Status
+
+
+ Neuer Konnektor
+
+
+ nein
+
+
+ Name der Passwort-Umgebungsvariablen (optional)
+
+
+ Passwort (optional)
+
+
+ Passwort (gespeichert – zum Ersetzen neu eingeben)
+
+
+ Port
+
+
+ Namen einer Umgebungsvariablen
+
+
+ Secrets werden hier niemals gespeichert. Zugangsdaten/Tokens werden über den
+
+
+ (oder eines Docker-Secrets) referenziert und zur Laufzeit aufgelöst.
+
+
+ Die Basis-URL weicht von der gespeicherten ab. Für einen Test gegen einen anderen Host das Token erneut eingeben – ein gespeichertes Token wird nur an den Host gesendet, für den es gespeichert wurde.
+
+
+ Die Basis-URL ist erforderlich.
+
+
+ Verbunden — Home-Assistant-API erreichbar, Token akzeptiert.
+
+
+ Verbunden — {0} = {1}.
+
+
+ Verbindung testen
+
+
+ Test-Entity-ID (optional, z. B. sensor.house_power)
+
+
+ Die Umgebungsvariable „{0}“ ist auf dem Server nicht gesetzt. Die Variable dort setzen und die App neu starten – oder „Token hier eingeben“ aktivieren, um das Token direkt zu speichern.
+
+
+ Verbindung fehlgeschlagen: {0}
+
+
+ Home Assistant antwortete mit {0}.
+
+
+ Verbunden, aber „{0}“ hat keinen numerischen Zustand (nicht verfügbar, unbekannt oder keine Zahl).
+
+
+ Zuerst ein Token eingeben.
+
+
+ Die Umgebungsvariable mit dem Token benennen oder „Token hier eingeben“ aktivieren.
+
+
+ Kein Token zum Testen vorhanden.
+
+
+ TLS
+
+
+ Langlebiges Zugriffstoken
+
+
+ Name der Token-Umgebungsvariablen (z. B. HA_TOKEN)
+
+
+ Name der Variablen
+
+
+ Der
+
+
+ , nicht das Token. Auf dem Server setzen und die App neu starten.
+
+
+ Token eingeben oder „Token hier eingeben“ deaktivieren und eine Umgebungsvariable benennen.
+
+
+ Langlebiges Zugriffstoken (gespeichert – zum Ersetzen neu eingeben)
+
+
+ Name der Benutzernamen-Umgebungsvariablen (optional)
+
+
+ Benutzername (optional)
+
+
+ Ein: Zustandsänderungen abonnieren und in Echtzeit erfassen. Aus: REST-Abfrage im Intervall der jeweiligen Quelle.
+
+
+ Echtzeit-Push über WebSocket
+
+
+ ja
+
+
+ Stand {0}
+
+
+ Brennerstunden
+
+
+ Verbrauch je Monat
+
+
+ Lieferungen ({0})
+
+
+ Verbrauchsrate
+
+
+ {0} % von {1} {2}
+
+
+ Voraussichtlich leer
+
+
+ Keine Lieferungen erfasst.
+
+
+ Keine Zähler für Vorräte gefunden. Legen Sie einen Zähler mit dem Modus
+
+
+ und einem Tank an oder laden Sie die Referenzdaten über
+
+
+ Vorräte
+
+
+ ({0} {1}/Tag)
+
+
+ Füllstand
+
+
+ Verbrauch ({0})
+
+
+ Verbrauch (Zeitraum)
+
+
+ Kategorie
+
+
+ Dieses Jahr
+
+
+ Vorjahr
+
+
+ Letzter Monat mit Daten
+
+
+ Noch keine Kostendaten – Tabelle importieren oder Tarife anlegen.
+
+
+ Dieser Monat
+
+
+ Was mehr / weniger kostet (Jahr vs. Vorjahr)
+
+
+ Größte Kostenanteile (dieses Jahr)
+
+
+ Energieart hinzufügen
+
+
+ Basiseinheit
+
+
+ Basiseinheit (kWh, m3, L, h)
+
+
+ Farbe als Hex-Wert (optional, z. B. #4caf50)
+
+
+ Standardmodus
+
+
+ Löschen nicht möglich: „{0}“ wird noch von {1} Zähler(n) verwendet.
+
+
+ „{0}“ wirklich löschen? Das kann nicht rückgängig gemacht werden.
+
+
+ Energieart löschen
+
+
+ Anzeigename
+
+
+ {0} bearbeiten
+
+
+ Icon (optional)
+
+
+ Schlüssel
+
+
+ Schlüssel „{0}“ wird bereits verwendet.
+
+
+ Schlüssel (stabiler technischer Schlüssel, z. B. electricity)
+
+
+ Neue Energieart
+
+
+ Schlüssel, Anzeigename und Basiseinheit sind erforderlich.
+
+
+ Verbrauch
+
+
+ Nachgelagerte Zähler
+
+
+ Energie
+
+
+ Energiefluss
+
+
+ Wohin der Fluss der obersten Ebene geht. Pfeilstärke ∝ Menge; „Sonstige“ ist der nicht erfasste Rest.
+
+
+ Fluss: {0}
+
+
+ Noch keine Zählerkette konfiguriert. Unter
+
+
+ → einen Unterzähler bearbeiten und dessen
+
+
+ festlegen, um zu zeigen, wie sich der Fluss des Hauptzählers aufteilt (z. B. Haupt → Auto, Pool, Sonstiges).
+
+
+ vorgelagerte Zähler
+
+
+ Für diese Energieart gibt es noch keine Zähler. Legen Sie welche an unter
+
+
+ oder laden Sie Referenzdaten über
+
+
+ Gesamtdurchsatz
+
+
+ Verbrauch
+
+
+ Erzeugung
+
+
+ Home Assistant
+
+
+ MQTT-Broker
+
+
+ Lieferung
+
+
+ Ignorieren
+
+
+ Manuelle Kosten
+
+
+ Zählerstand
+
+
+ Füllstand
+
+
+ Korrektur
+
+
+ Zählerreset
+
+
+ Lieferung
+
+
+ Zählerwechsel
+
+
+ Notiz
+
+
+ Füllstand
+
+
+ Tankbestand
+
+
+ Zählerstand (kumulativ)
+
+
+ Direkte Differenz
+
+
+ Erzeugungszähler
+
+
+ Momentanwert
+
+
+ Betriebsstundenzähler
+
+
+ Virtuell
+
+
+ Anomalie
+
+
+ Zählerreset
+
+
+ Zählerwechsel
+
+
+ Geschätzt
+
+
+ Importiert
+
+
+ Interpoliert
+
+
+ Manuell
+
+
+ Gemessen
+
+
+ Home Assistant
+
+
+ Import
+
+
+ Manuell
+
+
+ MQTT
+
+
+ Tasmota
+
+
+ Virtuell
+
+
+ Differenz
+
+
+ Füllstand
+
+
+ Momentanwert
+
+
+ Zählerstand
+
+
+ Betriebsstunden
+
+
+ Empirisch
+
+
+ Fest
+
+
+ Grundpreis
+
+
+ Bonus
+
+
+ Rabatt
+
+
+ Einspeisevergütung
+
+
+ Steuer
+
+
+ Arbeitspreis
+
+
+ Energieart
+
+
+ Global
+
+
+ Zähler
+
+
+ Zulässig
+
+
+ nicht aktiviert (MeterVault__AllowInAppUpdate)
+
+
+ auf dieser Installation nicht unterstützt
+
+
+ Für lokales Debugging die Umgebung {0} aktivieren: dazu die Umgebungsvariable {1} auf {0} setzen und die App neu starten.
+
+
+ Entwicklungsmodus
+
+
+ Ein Wechsel in die Umgebung {0} zeigt ausführlichere Informationen zu dem aufgetretenen Fehler.
+
+
+ Die Umgebung Development sollte in produktiven Installationen nicht aktiviert sein.
+
+
+ Sie kann vertrauliche Informationen aus Ausnahmen für Endnutzer sichtbar machen.
+
+
+ Fehler.
+
+
+ Bei der Verarbeitung der Anfrage ist ein Fehler aufgetreten.
+
+
+ Fehler
+
+
+ Anfrage-ID:
+
+
+ Sonstige ({0})
+
+
+ Zeile {0}: Zählerstand von Zähler {1} ist von {2} auf {3} gefallen; ein Zählerwechsel wurde angelegt (bitte prüfen).
+
+
+ Zeile {0}: Zählerstand von Zähler {1} ist von {2} auf {3} gefallen; Verbrauch über den Wechsel auf {4} gesetzt.
+
+
+ Zeile {0}: übersprungen ({1}).
+
+
+ Zeile {0}: Einheit „{1}“ erwartet, „{2}“ gefunden.
+
+
+ Zeile {0}: Datum nicht lesbar, übersprungen.
+
+
+ Zurück zum Import
+
+
+ CSV wählen
+
+
+ Spalte {0}
+
+
+ Spalte {0}: {1}
+
+
+ Import übernehmen
+
+
+ Übernahme fehlgeschlagen: {0}
+
+
+ Import #{0} übernommen: {1} Zeilen. Verbrauch neu berechnet.
+
+
+ Automatisch erkennen
+
+
+ Datumsspalte
+
+
+ Tag (31.12.2024)
+
+
+ Datumsformat
+
+
+ Monatsname (Januar 2024)
+
+
+ Zählerwechsel erkennen
+
+
+ Probelauf
+
+
+ {0} Zeilen, {1} Spalten
+
+
+ Erste Datenzeile
+
+
+ Spalte
+
+
+ Rolle
+
+
+ Kopfzeile
+
+
+ Beispiel
+
+
+ Beliebige CSV hochladen, ihre Spalten den Zählern und Kategorien zuordnen, die Vorschau prüfen und als Import übernehmen, der sich jederzeit zurücknehmen lässt. Werte dürfen im deutschen Format vorliegen (Dezimalkomma, Einheitensuffixe,
+
+
+ oder
+
+
+ als Datum) — derselbe Parser wie bei den Referenzblättern.
+
+
+ Die Zuordnung hat sich nach der Vorschau geändert. Erneut einen Probelauf ausführen und dann übernehmen.
+
+
+ Zähler {0}
+
+
+ Nichts zu importieren. Bitte oben erste Datenzeile, Datumsspalte und Spaltenzuordnung prüfen.
+
+
+ Abgeblendete Zeilen liegen vor der ersten Datenzeile. Die Spalte mit 📅 liefert das Datum.
+
+
+ Kategorie wählen
+
+
+ Zähler wählen
+
+
+ Nullzeilen überspringen
+
+
+ 1. Einleseoptionen
+
+
+ 2. Spaltenvorschau
+
+
+ 3. Spalten zuordnen
+
+
+ 4. Vorschau & Übernahme
+
+
+ Import-Assistent
+
+
+ z. B. kWh
+
+
+ {0} sind alle „{1}“ zugeordnet. Jede Spalte mit der Rolle „Zählerstand“ braucht einen eigenen Zähler.
+
+
+ Spalte {0} („Manuelle Kosten“) braucht eine Zielkategorie.
+
+
+ Spalte {0} („{1}“) braucht einen Zielzähler.
+
+
+ Mindestens eine Spalte muss einer anderen Rolle als „Ignorieren“ zugeordnet sein.
+
+
+ Import #{0} zurückgenommen.
+
+
+ Importiert am
+
+
+ Zeilen
+
+
+ Quelle
+
+
+ Probelauf mit Referenzblatt
+
+
+ Import fehlgeschlagen: {0}
+
+
+ Referenzdaten laden
+
+
+ Zuordnungsassistent
+
+
+ Noch keine Importe.
+
+
+ Kosten
+
+
+ Strom
+
+
+ Heizöl
+
+
+ Wasser
+
+
+ Letzte Importe
+
+
+ Referenzdaten geladen.
+
+
+ Referenzdatensatz
+
+
+ Die mitgelieferten Energiebilanz-Tabellen (Strom, Wasser, Heizöl, Kosten) als Startdatensatz mit Zählern, Tarifen und Kategorien laden.
+
+
+ Geladen
+
+
+ Referenzprofil
+
+
+ Zurücknehmen
+
+
+ Alle {0} Zeilen aus Import #{1} ({2}) löschen und die betroffenen Zähler neu berechnen?
+
+
+ Import zurücknehmen?
+
+
+ Zurücknehmen fehlgeschlagen: {0}
+
+
+ aktiv
+
+
+ zurückgenommen
+
+
+ ohne Namen
+
+
+ {0} Warnungen
+
+
+ Eigene CSV
+
+
+ Die Spalten einer beliebigen Tabelle den eigenen Zählern und Kategorien zuordnen, in der Vorschau prüfen und als Import übernehmen, der sich jederzeit zurücknehmen lässt. Oder unten mit einem der mitgelieferten Referenzprofile einen Probelauf machen.
+
+
+ Dunkler Modus
+
+
+ Sprache
+
+
+ Heller Modus
+
+
+ Neu laden
+
+
+ Navigation umschalten
+
+
+ Ein unbehandelter Fehler ist aufgetreten.
+
+
+ etwa gleich
+
+
+ Zählerstand erfassen
+
+
+ Zählerstand erfassen — {0}
+
+
+ Quelle hinzufügen
+
+
+ Attribut (optional; leer = state)
+
+
+ Zurück zur Zählerliste
+
+
+ Der Zeitpunkt liegt vor dem letzten Zählerstand — der Verbrauch wird ab dort neu berechnet.
+
+
+ (Anfangs-Zählerstand {0})
+
+
+ {0} {1} seit dem letzten Stand
+
+
+ Komponente
+
+
+ Konnektor
+
+
+ „{0}“ ist deaktiviert; diese Quelle würde also nie Daten erfassen. Zuerst aktivieren.
+
+
+ „{0}“ ist ein {1}-Konnektor; eine {2}-Quelle benötigt {3}.
+
+
+ Kosten dieses Jahr
+
+
+ (einmal einrichten; jede Quelle wählt ihn danach nur noch aus).
+
+
+ einen anlegen
+
+
+ Unter dem letzten Zählerstand ({0} {1}) bei einem Zählwerk, das nur vorwärts zählt — der Wert wird abgelehnt. Nach einem Zählerwechsel oder Zählerreset dieses Ereignis zuerst im Tab „Ereignisse“ erfassen.
+
+
+ Diese {0}-Quelle löschen?
+
+
+ Quelle löschen
+
+
+ Quelle bearbeiten
+
+
+ Wert eingeben
+
+
+ Entity-ID (z. B. sensor.house_power)
+
+
+ Flags
+
+
+ Von
+
+
+ Dieser Zeitpunkt liegt in der Zukunft.
+
+
+ Art
+
+
+ {0} diesen Monat
+
+
+ Vormonat {0} {1}
+
+
+ Letzter Zählerstand {0} {1} am {2}.
+
+
+ Letzter Wert
+
+
+ · {0} im Vorjahr
+
+
+ Gesamt seit Beginn
+
+
+ Ortszeit in {0}.
+
+
+ Diesen Zähler gibt es nicht mehr.
+
+
+ Neue Quelle
+
+
+ nein
+
+
+ noch kein Vergleich
+
+
+ keine Änderung seit dem letzten Stand
+
+
+ Noch kein {0}-Konnektor —
+
+
+ Noch kein normalisierter Verbrauch.
+
+
+ Keine Ereignisse (Zählerwechsel, Lieferungen, Korrekturen).
+
+
+ Noch keine Rohdaten.
+
+
+ Noch keine Zählerstände — vorbelegt mit dem Anfangs-Zählerstand ({0} {1}).
+
+
+ Diesem Zähler ist keine Quelle zugeordnet. Eine Quelle hinzufügen, um Daten von MQTT/Tasmota oder Home Assistant zu erfassen.
+
+
+ Keine passenden Tarife.
+
+
+ Zähler #{0} nicht gefunden.
+
+
+ Notizen
+
+
+ Offset
+
+
+ Für diese {1}-Quelle einen {0}-Konnektor auswählen.
+
+
+ Stündlich reicht für einen Zähler völlig — Monatssummen und Kosten sind identisch, bei deutlich weniger Rohdaten.
+
+
+ Abfrageintervall (Minuten)
+
+
+ Alt→Neu
+
+
+ Priorität
+
+
+ „{0}“ ist deaktiviert
+
+
+ kein Konnektor — erfasst nie Daten
+
+
+ „{0}“ ist {1}, benötigt {2}
+
+
+ ≈ {0} {1} bis Monatsende
+
+
+ ≈ {0} {1} im Gesamtjahr
+
+
+ Qualität
+
+
+ Zählerstand ({0})
+
+
+ Abgelehnt — unter dem vorherigen Zählerstand bei einem Zählwerk, das nur vorwärts zählt. Zuerst einen Zählerreset oder Zählerwechsel erfassen.
+
+
+ Zählerstand zu diesem Zeitpunkt ersetzt durch {0} {1}.
+
+
+ Zählerstand gespeichert: {0} {1}.
+
+
+ Zählerstände
+
+
+ Die letzten {0} normalisierten Differenzen.
+
+
+ Die letzten {0} (Rohdaten, unveränderlich und revisionssicher). Zeiten in {1}.
+
+
+ Details zum Zählwerk
+
+
+ Zählwerk (von → bis)
+
+
+ Für diesen Zeitpunkt gibt es bereits einen Zählerstand — beim Speichern wird sein Wert ersetzt.
+
+
+ stillgelegt
+
+
+ Zählerstand speichern
+
+
+ Wird gespeichert…
+
+
+ Skalierung
+
+
+ Diese Uhrzeit gab es in {0} nicht — die Uhren wurden vorgestellt. Bitte eine andere Zeit wählen.
+
+
+ Quelle gelöscht.
+
+
+ Quelle gespeichert.
+
+
+ Quellentyp
+
+
+ Verbrauch ({0})
+
+
+ Ereignisse ({0})
+
+
+ Zählerstände ({0})
+
+
+ Quellen ({0})
+
+
+ Tarife ({0})
+
+
+ offen
+
+
+ Zeit
+
+
+ Uhrzeit
+
+
+ Zeitpfad (optional, z. B. Time)
+
+
+ Bis
+
+
+ MQTT-Topic (z. B. tele/plug1/SENSOR)
+
+
+ Wertart
+
+
+ Wertpfad (z. B. ENERGY.Total; leer = einfacher Zahlenwert)
+
+
+ Ein virtueller Zähler berechnet sich per Formel aus anderen Zählern und speichert keine eigenen Zählerstände — den Zählerstand an dem Zähler eintragen, auf den sich die Formel bezieht.
+
+
+ Virtueller Zähler — sein Wert wird beim Abruf per Formel aus anderen Zählern berechnet; er hat also keine eigene gespeicherte Zeitreihe.
+
+
+ Die Werte stehen unter Trends.
+
+
+ ggü. Vormonat
+
+
+ {0} ggü. {1} im Vorjahr
+
+
+ — wird abgelehnt
+
+
+ ja
+
+
+ Aktiv
+
+
+ Zähler hinzufügen
+
+
+ „{0}“ wirklich löschen? Das kann nicht rückgängig gemacht werden.
+
+
+ „{0}“ wirklich löschen? Dabei werden auch {1} Zählerstände und {2} Verbrauchswerte gelöscht. Das kann nicht rückgängig gemacht werden.
+
+
+ Zähler löschen
+
+
+ {0} bearbeiten
+
+
+ die Referenzdaten.
+
+
+ Noch keine Zähler. Legen Sie einen an oder laden Sie über
+
+
+ Anfangs-Zählerstand
+
+
+ in der Einheit dieses Zählers (z. B. kW für kWh, L/h für L): eine Quelle, die W oder L/min meldet, braucht dafür einen Skalierungsfaktor.
+
+
+ Leistungs-/Durchflusssensor — Messwerte sind ein Momentanwert, der über die Zeit zum Verbrauch integriert wird. Hinterlegen Sie den Wert als
+
+
+ Stundenrate
+
+
+ Standort (optional)
+
+
+ Hersteller (optional)
+
+
+ Messmodus
+
+
+ Modell (optional)
+
+
+ Neuer Zähler
+
+
+ nein
+
+
+ PV-Rolle (optional)
+
+
+ Modus/Anfangs-Zählerstand geändert — der Verbrauch wird beim Speichern neu berechnet.
+
+
+ Name, Energieart und Einheit sind erforderlich.
+
+
+ — keine —
+
+
+ Seriennummer (optional)
+
+
+ Quellen
+
+
+ Dieser Zähler misst einen Teilbereich des Flusses der gewählten Zähler.
+
+
+ Unterzähler von (vorgelagerte Zähler)
+
+
+ Virtueller „Summen“-Zähler — er hat keine eigenen Zählerstände. In der Flussansicht entspricht er der Summe der unten gewählten vorgelagerten Zähler (z. B. Summe Solar = Solar 1 + Solar 2).
+
+
+ ja
+
+
+ Verwaltung
+
+
+ Konnektoren
+
+
+ Öl / Vorräte
+
+
+ Kostenkategorien
+
+
+ Energiearten
+
+
+ Import
+
+
+ Zähler
+
+
+ Übersicht
+
+
+ Einstellungen
+
+
+ Solar / PV
+
+
+ Tarife
+
+
+ Trends
+
+
+ Der gesuchte Inhalt existiert leider nicht.
+
+
+ Nicht gefunden
+
+
+ Die Sitzung wurde vom Server pausiert.
+
+
+ Verbindung konnte nicht wiederhergestellt werden.
+
+
+ Verbindung zum Server wird wiederhergestellt...
+
+
+ Fortsetzen
+
+
+ Die Sitzung konnte nicht fortgesetzt werden.
+
+
+ Erneut versuchen
+
+
+ Verbindung fehlgeschlagen... nächster Versuch in
+
+
+ Sekunden.
+
+
+ Bitte erneut versuchen oder die Seite neu laden.
+
+
+ Flussdiagramm
+
+
+ Kein Fluss in diesem Zeitraum.
+
+
+ Zugriff & Datenerfassung
+
+
+ geschlossen (401)
+
+
+ API-Dokumentation unter
+
+
+ {0} Schlüssel konfiguriert
+
+
+ Die Schlüssel selbst werden hier nie angezeigt.
+
+
+ API-Schlüssel setzt man über
+
+
+ offen (anonym)
+
+
+ tatsächlich wirksamen
+
+
+ Dies sind die
+
+
+ Einstellungen dieser laufenden Instanz. Sie werden über Umgebungsvariablen
+
+
+ oder Docker/Compose gesetzt und nicht in der Datenbank gespeichert — so bleibt die Konfiguration reproduzierbar und Zugangsdaten landen nie in der DB. Zum Ändern die Compose-/Env-Konfiguration anpassen und neu starten.
+
+
+ Umgebungsvariablen:
+
+
+ Live-Erfassungsdienste
+
+
+ Gebietsschema
+
+
+ Gebietsschema & Zeit
+
+
+ aus
+
+
+ ein
+
+
+ Aufbewahrung der Rohdaten
+
+
+ {0} Tage
+
+
+ Reverse-Proxy vertrauen
+
+
+ Referenzdaten beim Start anlegen
+
+
+ Zeitzone
+
+
+ Autarkie
+
+
+ Erzeugung
+
+
+ Erzeugung & Eigenverbrauch
+
+
+ Erzeugung je Zähler
+
+
+ Netzbezug {0} kWh
+
+
+ Keine Erzeugungszähler gefunden. Legen Sie einen Zähler mit dem Modus
+
+
+ an oder laden Sie die Referenzdaten über
+
+
+ Ersparnis
+
+
+ Eigenverbrauch
+
+
+ {0} % der Erzeugung
+
+
+ Markieren Sie einen Zähler als
+
+
+ und einen als
+
+
+ (in den Zähler-Metadaten), um Eigenverbrauch, Autarkie und Ersparnis freizuschalten.
+
+
+ Tarif hinzufügen
+
+
+ Komponente
+
+
+ Diesen {0}-Tarif löschen ({1} {2})?
+
+
+ Tarif löschen
+
+
+ Tarif bearbeiten
+
+
+ Noch keine Tarife vorhanden. Neu anlegen oder Referenzdaten laden unter
+
+
+ Neuer Tarif
+
+
+ Notizen (optional)
+
+
+ offen
+
+
+ Global
+
+
+ Zähler: {0}
+
+
+ Bitte auswählen, für welche Energieart oder welchen Zähler der Tarif gilt.
+
+
+ Energieart: {0}
+
+
+ Einheit und „Gültig ab“ sind erforderlich.
+
+
+ Einheit (z. B. EUR/kWh, EUR/m3, EUR/month)
+
+
+ Gültig ab
+
+
+ Gültig bis
+
+
+ Gültig bis (leer = unbefristet)
+
+
+ Monatliche Kosten
+
+
+ Anwenden
+
+
+ Letzte 48 Monate
+
+
+ Kostenverlauf
+
+
+ Gesamt im Zeitraum: {0}
+
+
+ Dabei wird der aktuelle Quellcode geladen, neu gebaut und der Dienst neu gestartet. Das dauert einige Minuten, in denen MeterVault nicht erreichbar ist. Zählerstände sind nicht betroffen — die Erfassung läuft nach dem Neustart weiter.
+
+
+ MeterVault aktualisieren
+
+
+ das neue Image ziehen und den Container neu erstellen
+
+
+ ausführen: update
+
+
+ MeterVault {0} ist verfügbar — diese Instanz läuft mit {1}.
+
+
+ Wird gestartet…
+
+
+ Jetzt aktualisieren
+
+
+ Das Update konnte nicht gestartet werden.
+
+
+ Das Update konnte nicht gestartet werden: {0}
+
+
+ systemd-run konnte nicht gestartet werden.
+
+
+ Das Update kann nicht gestartet werden: {0}.
+
+
+ Update gestartet. Der Dienst startet neu, sobald der Build fertig ist — das dauert meist einige Minuten.
+
+
diff --git a/src/App/Localization/Strings.resx b/src/App/Localization/Strings.resx
new file mode 100644
index 0000000..dcfb651
--- /dev/null
+++ b/src/App/Localization/Strings.resx
@@ -0,0 +1,1635 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ Add
+
+
+ Add category
+
+
+ Add energy type
+
+
+ Add meter
+
+
+ Close
+
+
+ Color hex (optional, e.g. #ff9800)
+
+
+ Delete '{0}' and its {1} membership(s)? Manual costs in this category are kept but unlinked.
+
+
+ Delete category
+
+
+ Edit {0}
+
+
+ Meter: {0}
+
+
+ {0} meter(s), {1} type(s)
+
+
+ Type: {0}
+
+
+ Members
+
+
+ New category
+
+
+ No members yet — add a meter or an energy type.
+
+
+ Save the category first to add members.
+
+
+ Saved. Add members below.
+
+
+ Sort
+
+
+ Sort order
+
+
+ Cost
+
+
+ Actions
+
+
+ Amount
+
+
+ Cancel
+
+
+ Cost (range)
+
+
+ Currency
+
+
+ Date
+
+
+ Delete
+
+
+ Deleted.
+
+
+ Enabled
+
+
+ Energy type
+
+
+ Events:
+
+
+ Last seen
+
+
+ Manual costs:
+
+
+ Meter
+
+
+ Meters
+
+
+ Mode
+
+
+ Name
+
+
+ Name is required.
+
+
+ No data in this range.
+
+
+ Now
+
+
+ Preview
+
+
+ Range
+
+
+ All time
+
+
+ Last 12 months
+
+
+ Last 24 months
+
+
+ Last 5 years
+
+
+ Readings:
+
+
+ Save
+
+
+ Saved.
+
+
+ Scope
+
+
+ Skipped rows:
+
+
+ Status
+
+
+ Target
+
+
+ This year
+
+
+ Type
+
+
+ Unit
+
+
+ Value
+
+
+ Add connector
+
+
+ Base URL (e.g. http://homeassistant.local:8123)
+
+
+ Delete '{0}'?
+
+
+ {0} source(s) use it and will stop ingesting until reassigned to another connector.
+
+
+ Delete connector
+
+
+ Edit {0}
+
+
+ No connectors yet. Add an MQTT broker or a Home Assistant connection.
+
+
+ Encrypted before it is stored; database dumps and JSON exports carry nothing usable.
+
+
+ Enter credentials here
+
+
+ Enter the token here
+
+
+ Extra topics (comma-separated, optional)
+
+
+ Host
+
+
+ Last status
+
+
+ New connector
+
+
+ no
+
+
+ Password env-var name (optional)
+
+
+ Password (optional)
+
+
+ Password (stored — type to replace)
+
+
+ Port
+
+
+ name of an environment variable
+
+
+ Secrets are never stored here. Credentials/tokens are referenced by the
+
+
+ (or Docker secret) resolved at runtime.
+
+
+ Base URL differs from the saved one. Re-enter the token to test against a different host — a stored token is only sent to the host it was saved for.
+
+
+ Base URL is required.
+
+
+ Connected — Home Assistant API reachable and token accepted.
+
+
+ Connected — {0} = {1}.
+
+
+ Test connection
+
+
+ Test entity id (optional, e.g. sensor.house_power)
+
+
+ Environment variable '{0}' is not set on the server. Set it and restart the app, or switch on "Enter the token here" to store the token directly.
+
+
+ Connection failed: {0}
+
+
+ Home Assistant answered {0}.
+
+
+ Connected, but "{0}" has no numeric state (unavailable, unknown or not a number).
+
+
+ Enter a token first.
+
+
+ Name the environment variable holding the token, or switch on "Enter the token here".
+
+
+ No token available to test.
+
+
+ TLS
+
+
+ Long-lived access token
+
+
+ Token env-var name (e.g. HA_TOKEN)
+
+
+ name
+
+
+ The variable's
+
+
+ , not the token. Set it on the server and restart the app.
+
+
+ Enter the token, or switch off "Enter the token here" and name an env var.
+
+
+ Long-lived access token (stored — type to replace)
+
+
+ Username env-var name (optional)
+
+
+ Username (optional)
+
+
+ On: subscribe to state changes and ingest in real time. Off: REST poll on each source's interval.
+
+
+ Real-time WebSocket push
+
+
+ yes
+
+
+ as of {0}
+
+
+ Burner runtime
+
+
+ Consumption by month
+
+
+ Deliveries ({0})
+
+
+ Effective rate
+
+
+ {0}% of {1} {2}
+
+
+ Forecast to empty
+
+
+ No deliveries recorded.
+
+
+ No consumable meters found. Add a meter with mode
+
+
+ and a tank, or load the reference data from
+
+
+ Consumables
+
+
+ ({0} {1}/day)
+
+
+ Tank level
+
+
+ {0} used
+
+
+ Used (range)
+
+
+ Category
+
+
+ Now
+
+
+ Prev
+
+
+ Latest month with data
+
+
+ No cost data yet — import a sheet or add tariffs.
+
+
+ This month
+
+
+ What cost more / less (year vs last year)
+
+
+ What costs most (this year)
+
+
+ Add energy type
+
+
+ Base unit
+
+
+ Base unit (kWh, m3, L, h)
+
+
+ Color hex (optional, e.g. #4caf50)
+
+
+ Default mode
+
+
+ Cannot delete '{0}': {1} meter(s) still use it.
+
+
+ Delete '{0}'? This cannot be undone.
+
+
+ Delete energy type
+
+
+ Display name
+
+
+ Edit {0}
+
+
+ Icon (optional)
+
+
+ Key
+
+
+ Key '{0}' is already in use.
+
+
+ Key (stable machine key, e.g. electricity)
+
+
+ New energy type
+
+
+ Key, display name and base unit are required.
+
+
+ Consumption
+
+
+ Upstream of
+
+
+ Energy
+
+
+ Flow
+
+
+ Where the top-level flow goes. Arrow thickness ∝ amount; "Other" is the unmetered remainder.
+
+
+ {0} flow
+
+
+ No meter chain configured yet. In
+
+
+ → edit a sub-meter and set its
+
+
+ to show where the main meter's flow divides (e.g. main → car, pool, other).
+
+
+ upstream meter(s)
+
+
+ No meters for this energy type yet. Add meters in
+
+
+ , or load the reference data from
+
+
+ Top-level throughput
+
+
+ Consumption
+
+
+ Generation
+
+
+ Home Assistant
+
+
+ MQTT broker
+
+
+ Delivery
+
+
+ Ignore
+
+
+ Manual cost
+
+
+ Reading
+
+
+ Tank level
+
+
+ Correction
+
+
+ Counter reset
+
+
+ Delivery
+
+
+ Meter swap
+
+
+ Note
+
+
+ Tank level
+
+
+ Consumable balance
+
+
+ Cumulative counter
+
+
+ Direct delta
+
+
+ Generation counter
+
+
+ Instant rate
+
+
+ Runtime counter
+
+
+ Virtual
+
+
+ Anomaly
+
+
+ Counter reset
+
+
+ Meter swap
+
+
+ Estimated
+
+
+ Imported
+
+
+ Interpolated
+
+
+ Manual
+
+
+ Measured
+
+
+ Home Assistant
+
+
+ Import
+
+
+ Manual
+
+
+ MQTT
+
+
+ Tasmota
+
+
+ Virtual
+
+
+ Delta
+
+
+ Level
+
+
+ Rate
+
+
+ Register
+
+
+ Runtime
+
+
+ Empirical
+
+
+ Fixed
+
+
+ Base price
+
+
+ Bonus
+
+
+ Discount
+
+
+ Feed-in
+
+
+ Tax
+
+
+ Unit price
+
+
+ Energy type
+
+
+ Global
+
+
+ Meter
+
+
+ Allowed
+
+
+ not enabled (MeterVault__AllowInAppUpdate)
+
+
+ not supported on this install
+
+
+ For local debugging, enable the {0} environment by setting the {1} environment variable to {0} and restarting the app.
+
+
+ Development Mode
+
+
+ Swapping to {0} environment will display more detailed information about the error that occurred.
+
+
+ The Development environment shouldn't be enabled for deployed applications.
+
+
+ It can result in displaying sensitive information from exceptions to end users.
+
+
+ Error.
+
+
+ An error occurred while processing your request.
+
+
+ Error
+
+
+ Request ID:
+
+
+ Other ({0})
+
+
+ Row {0}: register for meter {1} fell {2}→{3}; a swap event was created (please check).
+
+
+ Row {0}: register for meter {1} fell {2}→{3}; consumption across the swap set to {4}.
+
+
+ Row {0}: skipped ({1}).
+
+
+ Row {0}: expected unit "{1}" but found "{2}".
+
+
+ Row {0}: unparseable date, skipped.
+
+
+ Back to Import
+
+
+ Choose CSV
+
+
+ Col {0}
+
+
+ Col {0}: {1}
+
+
+ Commit import
+
+
+ Commit failed: {0}
+
+
+ Imported batch #{0}: {1} rows staged. Consumption recomputed.
+
+
+ Auto-detect
+
+
+ Date column
+
+
+ Day (31.12.2024)
+
+
+ Date format
+
+
+ Month name (Januar 2024)
+
+
+ Detect swaps
+
+
+ Dry-run preview
+
+
+ {0} rows, {1} columns
+
+
+ First data row
+
+
+ Column
+
+
+ Role
+
+
+ Header row
+
+
+ Sample
+
+
+ Upload any CSV, map its columns to your meters and categories, preview what would be staged, then commit it as a revertible import. Values may use the German dialect (decimal comma, unit suffixes,
+
+
+ or
+
+
+ dates) — the same parser the reference sheets use.
+
+
+ The mapping changed after the preview. Run the dry run again, then commit.
+
+
+ meter {0}
+
+
+ Nothing staged. Check the first-data-row, date column and column mappings above.
+
+
+ Faded rows are before the first data row. The 📅 column supplies the date.
+
+
+ Select category
+
+
+ Select meter
+
+
+ Skip zero rows
+
+
+ 1. Parsing options
+
+
+ 2. Column preview
+
+
+ 3. Map columns
+
+
+ 4. Preview & commit
+
+
+ Import wizard
+
+
+ e.g. kWh
+
+
+ {0} all read into '{1}'. Each Reading column needs its own meter.
+
+
+ Col {0} (ManualCost) needs a target category.
+
+
+ Col {0} ({1}) needs a target meter.
+
+
+ Map at least one column to a role other than Ignore.
+
+
+ Import #{0} reverted.
+
+
+ Imported
+
+
+ Rows
+
+
+ Source
+
+
+ Dry-run a reference sheet
+
+
+ Import failed: {0}
+
+
+ Load reference data
+
+
+ Mapping wizard
+
+
+ No imports yet.
+
+
+ Costs (Kosten)
+
+
+ Electricity (Strom)
+
+
+ Heating oil (Heizöl)
+
+
+ Water (Wasser)
+
+
+ Recent imports
+
+
+ Reference data loaded.
+
+
+ Reference dataset
+
+
+ Load the bundled Energiebilanz sheets (electricity, water, heating oil, costs) as a starter dataset with meters, tariffs and categories.
+
+
+ Loaded
+
+
+ Reference profile
+
+
+ Revert
+
+
+ Delete all {0} rows from import #{1} ({2}) and recompute the affected meters?
+
+
+ Revert import?
+
+
+ Revert failed: {0}
+
+
+ active
+
+
+ reverted
+
+
+ unnamed
+
+
+ {0} warnings
+
+
+ Your own CSV
+
+
+ Map an arbitrary sheet's columns to your meters/categories, preview and commit it as a revertible import. Or dry-run against one of the built-in reference profiles below.
+
+
+ Dark mode
+
+
+ Language
+
+
+ Light mode
+
+
+ Reload
+
+
+ Toggle navigation
+
+
+ An unhandled error has occurred.
+
+
+ about the same
+
+
+ Add reading
+
+
+ Add reading — {0}
+
+
+ Add source
+
+
+ Attribute (optional; blank = state)
+
+
+ Back to meters
+
+
+ Backdated before the latest reading — consumption from there on is recomputed.
+
+
+ (baseline {0})
+
+
+ {0} {1} since last reading
+
+
+ Component
+
+
+ Connector
+
+
+ '{0}' is disabled, so this source would never ingest. Enable it first.
+
+
+ '{0}' is a {1} connector; a {2} source needs {3}.
+
+
+ Cost this year
+
+
+ (set it up once; every source then just picks it).
+
+
+ create one
+
+
+ Below the last reading ({0} {1}) on a register that only counts up, so it will be rejected. If the meter was swapped or reset, record that on the Events tab first.
+
+
+ Delete this {0} source?
+
+
+ Delete source
+
+
+ Edit source
+
+
+ Enter a value
+
+
+ Entity id (e.g. sensor.house_power)
+
+
+ Flags
+
+
+ From
+
+
+ That time is in the future.
+
+
+ Kind
+
+
+ {0} this month
+
+
+ last month {0} {1}
+
+
+ Last reading {0} {1} on {2}.
+
+
+ Last value
+
+
+ · {0} last year
+
+
+ Lifetime total
+
+
+ Local time in {0}.
+
+
+ This meter no longer exists.
+
+
+ New source
+
+
+ no
+
+
+ no basis yet
+
+
+ no change since last reading
+
+
+ No {0} connector yet —
+
+
+ No normalized consumption yet.
+
+
+ No events (swaps, deliveries, corrections).
+
+
+ No raw readings.
+
+
+ No readings yet — prefilled with this meter's baseline ({0} {1}).
+
+
+ No ingest sources bound to this meter. Add one to pull from MQTT/Tasmota or Home Assistant.
+
+
+ No applicable tariffs.
+
+
+ Meter #{0} not found.
+
+
+ Notes
+
+
+ Offset
+
+
+ Pick a {0} connector for this {1} source.
+
+
+ Hourly is plenty for a meter — monthly totals and cost come out identical, with far less raw data.
+
+
+ Poll interval (minutes)
+
+
+ Prev→New
+
+
+ Priority
+
+
+ '{0}' is disabled
+
+
+ no connector — never ingests
+
+
+ '{0}' is {1}, needs {2}
+
+
+ ≈ {0} {1} by month end
+
+
+ ≈ {0} {1} full year
+
+
+ Quality
+
+
+ Reading ({0})
+
+
+ Rejected — below the previous reading on a register that only counts up. Record a counter reset or meter swap first.
+
+
+ Replaced the reading at that time with {0} {1}.
+
+
+ Reading saved: {0} {1}.
+
+
+ Readings
+
+
+ Most recent {0} normalized deltas.
+
+
+ Most recent {0} (raw, immutable audit truth). Times in {1}.
+
+
+ Meter register details
+
+
+ Register span
+
+
+ This meter already has a reading at that time — saving replaces its value.
+
+
+ retired
+
+
+ Save reading
+
+
+ Saving…
+
+
+ Scale
+
+
+ That clock time never happened in {0} — the clocks moved forward. Pick another time.
+
+
+ Source deleted.
+
+
+ Source saved.
+
+
+ Source type
+
+
+ Consumption ({0})
+
+
+ Events ({0})
+
+
+ Readings ({0})
+
+
+ Sources ({0})
+
+
+ Tariffs ({0})
+
+
+ open
+
+
+ Time
+
+
+ Time
+
+
+ Time path (optional, e.g. Time)
+
+
+ To
+
+
+ MQTT topic (e.g. tele/plug1/SENSOR)
+
+
+ Value kind
+
+
+ Value path (e.g. ENERGY.Total; blank = bare scalar)
+
+
+ A virtual meter is an expression over other meters, so it stores no readings of its own — enter the reading on the meter the expression refers to.
+
+
+ Virtual meter — its value is an expression over other meters, evaluated when read, so it has no stored series of its own.
+
+
+ See Trends for its figures.
+
+
+ vs last month
+
+
+ {0} vs {1} last year
+
+
+ — will be rejected
+
+
+ yes
+
+
+ Active
+
+
+ Add meter
+
+
+ Delete '{0}'? This cannot be undone.
+
+
+ Delete '{0}'? This will also delete {1} reading(s) and {2} consumption row(s). This cannot be undone.
+
+
+ Delete meter
+
+
+ Edit {0}
+
+
+ to load the reference data.
+
+
+ No meters yet. Add one, or go to
+
+
+ Initial register baseline
+
+
+ rate in this meter's unit (e.g. kW for kWh, L/h for L): a source reporting W or L/min should carry a scale factor to convert it first.
+
+
+ Power/flow sensor — readings are an instantaneous rate, integrated over time into consumption. Store the value as a
+
+
+ per-hour
+
+
+ Location (optional)
+
+
+ Manufacturer (optional)
+
+
+ Measurement mode
+
+
+ Model (optional)
+
+
+ New meter
+
+
+ no
+
+
+ PV role (optional)
+
+
+ Mode/baseline changed — consumption will be recomputed on save.
+
+
+ Name, energy type and unit are required.
+
+
+ — none —
+
+
+ Serial number (optional)
+
+
+ Sources
+
+
+ This meter measures a subsection of the selected meter(s)' flow.
+
+
+ Sub-meter of (upstream meters)
+
+
+ Virtual "sum" meter — it has no readings of its own. In the flow view it equals the sum of the upstream meters you select below (e.g. Sum Solar = Solar 1 + Solar 2).
+
+
+ yes
+
+
+ Admin
+
+
+ Connectors
+
+
+ Oil / consumables
+
+
+ Cost categories
+
+
+ Energy types
+
+
+ Import
+
+
+ Meters
+
+
+ Overview
+
+
+ Settings
+
+
+ Solar / PV
+
+
+ Tariffs
+
+
+ Trends
+
+
+ Sorry, the content you are looking for does not exist.
+
+
+ Not Found
+
+
+ The session has been paused by the server.
+
+
+ Failed to rejoin.
+
+
+ Rejoining the server...
+
+
+ Resume
+
+
+ Failed to resume the session.
+
+
+ Retry
+
+
+ Rejoin failed... trying again in
+
+
+ seconds.
+
+
+ Please retry or reload the page.
+
+
+ Flow diagram
+
+
+ No flow to show for this period.
+
+
+ Access & ingestion
+
+
+ closed (401)
+
+
+ API docs at
+
+
+ {0} key(s) configured
+
+
+ Keys themselves are never shown here.
+
+
+ Set API keys with
+
+
+ open (anonymous)
+
+
+ effective
+
+
+ These are the
+
+
+ settings the running instance is using. They are configured via environment variables
+
+
+ or Docker/compose, not stored in the database — so config stays reproducible and secrets never land in the DB. Change them in your compose/env and restart.
+
+
+ Env keys:
+
+
+ Live ingestion workers
+
+
+ Locale
+
+
+ Locale & time
+
+
+ off
+
+
+ on
+
+
+ Raw-reading retention
+
+
+ {0} days
+
+
+ Reverse-proxy trust
+
+
+ Seed reference data on start
+
+
+ Timezone
+
+
+ Autarky
+
+
+ Generation
+
+
+ Generation & self-consumption
+
+
+ Generation by meter
+
+
+ Grid draw {0} kWh
+
+
+ No generation meters found. Add a meter with mode
+
+
+ or load the reference data from
+
+
+ Savings (Ersparnis)
+
+
+ Self-consumption
+
+
+ {0}% of generation
+
+
+ Tag a meter
+
+
+ and one
+
+
+ (in meter metadata) to unlock self-consumption, autarky and savings.
+
+
+ Add tariff
+
+
+ Component
+
+
+ Delete this {0} tariff ({1} {2})?
+
+
+ Delete tariff
+
+
+ Edit tariff
+
+
+ No tariffs yet. Add one, or load the reference data from
+
+
+ New tariff
+
+
+ Notes (optional)
+
+
+ open
+
+
+ Global
+
+
+ Meter: {0}
+
+
+ Select the energy type or meter this tariff applies to.
+
+
+ Type: {0}
+
+
+ Unit and valid-from are required.
+
+
+ Unit (e.g. EUR/kWh, EUR/m3, EUR/month)
+
+
+ Valid from
+
+
+ Valid to
+
+
+ Valid to (empty = open-ended)
+
+
+ Monthly cost
+
+
+ Apply
+
+
+ Last 48 months
+
+
+ Cost trend
+
+
+ Total over range: {0}
+
+
+ This pulls the latest source, rebuilds it, and restarts the service. It takes a few minutes, during which MeterVault is unavailable. Readings are not affected — ingestion resumes on restart.
+
+
+ Update MeterVault
+
+
+ pull the new image and recreate the container
+
+
+ run: update
+
+
+ MeterVault {0} is available — this instance runs {1}.
+
+
+ Starting…
+
+
+ Update now
+
+
+ Could not start the update.
+
+
+ Could not start the update: {0}
+
+
+ Could not start systemd-run.
+
+
+ Update cannot be started: {0}.
+
+
+ Update started. The service restarts when the rebuild finishes — this usually takes a few minutes.
+
+
diff --git a/src/App/MeterVault.App.csproj b/src/App/MeterVault.App.csproj
index e1b6108..c59697d 100644
--- a/src/App/MeterVault.App.csproj
+++ b/src/App/MeterVault.App.csproj
@@ -26,4 +26,20 @@
+
+
+
+ MSBuild:Compile
+ $(IntermediateOutputPath)\Strings.Designer.cs
+ CSharp
+ MeterVault.App.Localization
+ Strings
+ true
+
+
+
diff --git a/src/App/Program.cs b/src/App/Program.cs
index 61e3782..f4edfd2 100644
--- a/src/App/Program.cs
+++ b/src/App/Program.cs
@@ -1,5 +1,6 @@
using MeterVault.App.Api;
using MeterVault.App.Components;
+using MeterVault.App.Localization;
using MeterVault.Infrastructure;
using MeterVault.Infrastructure.Options;
using MeterVault.Infrastructure.Persistence;
@@ -71,6 +72,7 @@ try
builder.Services.AddMeterVaultIngestion();
}
+ builder.Services.AddLocalization();
builder.Services.AddMudServices();
builder.Services.AddRazorComponents()
.AddInteractiveServerComponents();
@@ -100,6 +102,24 @@ try
// that terminates TLS (SDD §10). HTTPS redirection here would break the container and proxy.
app.UseAntiforgery();
+ // UI language (SDD §12, M7). Must run before MapRazorComponents: a Blazor Server circuit takes
+ // its culture from the request that opens it, so this is what every render downstream sees.
+ // Order of preference is the culture cookie the picker writes, then Accept-Language, then
+ // MeterVault__Locale — an instance can be pinned to one language, and a user can still switch.
+ // TryResolve yields the neutral fallback when it fails, so defaultCulture is usable either way.
+ if (!Loc.TryResolve(options.Locale, out var defaultCulture) && !string.IsNullOrWhiteSpace(options.Locale))
+ {
+ Log.Warning(
+ "MeterVault__Locale is '{Locale}', which has no translations; falling back to '{Fallback}'. "
+ + "Supported: {Supported}",
+ options.Locale, defaultCulture, string.Join(", ", Loc.SupportedCultures));
+ }
+
+ app.UseRequestLocalization(new RequestLocalizationOptions()
+ .SetDefaultCulture(defaultCulture)
+ .AddSupportedCultures([.. Loc.SupportedCultures])
+ .AddSupportedUICultures([.. Loc.SupportedCultures]));
+
app.UseSwagger();
app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "MeterVault API v1"));
@@ -108,6 +128,7 @@ try
.AddInteractiveServerRenderMode();
app.MapMeterVaultApi();
+ app.MapCultureEndpoints();
// Liveness/readiness probe for Gatus/Compose healthchecks (SDD §9).
app.MapGet("/healthz", () => Results.Ok(new { status = "ok" }));
diff --git a/src/Infrastructure/Dashboard/FlowModels.cs b/src/Infrastructure/Dashboard/FlowModels.cs
index ddb4469..55c5fb0 100644
--- a/src/Infrastructure/Dashboard/FlowModels.cs
+++ b/src/Infrastructure/Dashboard/FlowModels.cs
@@ -1,6 +1,11 @@
namespace MeterVault.Infrastructure.Dashboard;
/// A node in the flow graph: a meter, or a synthetic "Other/unmetered" remainder.
+///
+/// A meter's name — for a remainder node () the parent meter's
+/// name. The surrounding wording ("Other (…)") is the UI's to supply, because it is the only layer
+/// that knows the reader's language; see Flow_OtherNode.
+///
public sealed record FlowNode(string Id, string Label, double Value, int Depth, string? ColorHex, bool IsOther, int? MeterId);
/// A directed flow edge with the quantity that flows along it, in the energy type's base unit.
diff --git a/src/Infrastructure/Dashboard/FlowService.cs b/src/Infrastructure/Dashboard/FlowService.cs
index fd163e2..7c395e4 100644
--- a/src/Infrastructure/Dashboard/FlowService.cs
+++ b/src/Infrastructure/Dashboard/FlowService.cs
@@ -115,7 +115,9 @@ public sealed class FlowService(IDbContextFactory contextFa
if (remainder > Epsilon)
{
var otherId = $"other{meter.Id}";
- nodes.Add(new FlowNode(otherId, $"Other ({meter.Name})", remainder, depth.GetValueOrDefault(meter.Id) + 1, "#78909C", true, null));
+ // Just the parent's name: the "Other (…)" phrasing is added by the UI, which is
+ // where the reader's language is known.
+ nodes.Add(new FlowNode(otherId, meter.Name, remainder, depth.GetValueOrDefault(meter.Id) + 1, "#78909C", true, null));
flowLinks.Add(new FlowLink(NodeId(meter.Id), otherId, remainder));
}
}
diff --git a/src/Infrastructure/Dashboard/MeterDetailModels.cs b/src/Infrastructure/Dashboard/MeterDetailModels.cs
index 7c45118..1506839 100644
--- a/src/Infrastructure/Dashboard/MeterDetailModels.cs
+++ b/src/Infrastructure/Dashboard/MeterDetailModels.cs
@@ -14,7 +14,8 @@ public sealed record MeterMonthPoint(DateOnly Month, double Amount, double Cost)
///
/// A meter framed the way it is actually read: what it used this period, how that compares with the
/// last one, and where the year is heading. Amounts are generation for a generation counter and
-/// consumption otherwise, so says which.
+/// consumption otherwise, so says which — as the enum, not a word, because the
+/// wording belongs to whichever language the reader picked.
///
///
/// Month- and year-to-date are compared against a projection of the current period rather
@@ -22,7 +23,7 @@ public sealed record MeterMonthPoint(DateOnly Month, double Amount, double Cost)
/// collapse in usage when nothing has changed. Projections are flagged so the UI can mark them.
///
public sealed record MeterPeriodView(
- string Label,
+ ConsumptionKind Kind,
string Unit,
string Currency,
double MonthToDate,
diff --git a/src/Infrastructure/Dashboard/MeterPeriodService.cs b/src/Infrastructure/Dashboard/MeterPeriodService.cs
index 529095f..684adb5 100644
--- a/src/Infrastructure/Dashboard/MeterPeriodService.cs
+++ b/src/Infrastructure/Dashboard/MeterPeriodService.cs
@@ -86,7 +86,7 @@ public sealed class MeterPeriodService(
var yearToDateCost = SumYear(costs, today.Year);
return new MeterPeriodView(
- Label: isGeneration ? "Generation" : "Consumption",
+ Kind: kind,
Unit: meter.Unit,
Currency: _options.Currency,
MonthToDate: monthToDate,
diff --git a/src/Infrastructure/Import/CsvImporter.cs b/src/Infrastructure/Import/CsvImporter.cs
index 12a0504..093503a 100644
--- a/src/Infrastructure/Import/CsvImporter.cs
+++ b/src/Infrastructure/Import/CsvImporter.cs
@@ -31,7 +31,7 @@ public sealed class CsvImporter
staged.SkippedRows++;
if (!reason.StartsWith("blank", StringComparison.Ordinal))
{
- staged.Warnings.Add($"Row {r + 1}: skipped ({reason}).");
+ staged.Warnings.Add(ImportWarnings.RowSkipped(r + 1, reason));
}
continue;
@@ -40,7 +40,7 @@ public sealed class CsvImporter
if (!TryGetDate(row, profile, out var time))
{
staged.SkippedRows++;
- staged.Warnings.Add($"Row {r + 1}: unparseable date, skipped.");
+ staged.Warnings.Add(ImportWarnings.UnparseableDate(r + 1));
continue;
}
@@ -140,8 +140,7 @@ public sealed class CsvImporter
if (column.Unit is not null && split.Value.Unit is not null
&& !string.Equals(column.Unit, split.Value.Unit, StringComparison.OrdinalIgnoreCase))
{
- staged.Warnings.Add(
- $"Row {rowIndex + 1}: expected unit '{column.Unit}' but found '{split.Value.Unit}'.");
+ staged.Warnings.Add(ImportWarnings.UnitMismatch(rowIndex + 1, column.Unit, split.Value.Unit));
}
if (detectSwaps && previousByMeter.TryGetValue(meterId, out var previous) && value < previous)
@@ -157,9 +156,9 @@ public sealed class CsvImporter
Amount = override_,
Notes = "Auto-detected register decrease (meter swap / reset candidate).",
});
- staged.Warnings.Add(
- $"Row {rowIndex + 1}: register for meter {meterId} dropped {previous}→{value}; " +
- (override_ is null ? "swap event created (verify)." : $"swap consumption set to {override_}."));
+ staged.Warnings.Add(override_ is { } amount
+ ? ImportWarnings.RegisterDroppedWithAmount(rowIndex + 1, meterId, previous, value, amount)
+ : ImportWarnings.RegisterDropped(rowIndex + 1, meterId, previous, value));
}
staged.Readings.Add(new Reading
diff --git a/src/Infrastructure/Import/ImportWarning.cs b/src/Infrastructure/Import/ImportWarning.cs
new file mode 100644
index 0000000..643e2d1
--- /dev/null
+++ b/src/Infrastructure/Import/ImportWarning.cs
@@ -0,0 +1,74 @@
+using System.Globalization;
+
+namespace MeterVault.Infrastructure.Import;
+
+/// What a staging warning is about.
+public enum ImportWarningKind
+{
+ /// A row matched a skip rule (a summary line, an all-zero placeholder). Args: row, reason.
+ RowSkipped,
+
+ /// The date cell parsed as neither Monat JJJJ nor TT.MM.JJJJ. Args: row.
+ UnparseableDate,
+
+ /// The value carried a different unit suffix than the column expects. Args: row, expected, found.
+ UnitMismatch,
+
+ /// A register went backwards; a swap event was staged for review. Args: row, meter, previous, new.
+ RegisterDropped,
+
+ /// Same, with the consumption across the swap taken from the sheet. Args: row, meter, previous, new, amount.
+ RegisterDroppedWithAmount,
+}
+
+///
+/// One thing worth telling the user about a staged row.
+///
+///
+/// The English sentence, kept for logs and any non-UI caller.
+///
+///
+/// The values that filled it, in order. The UI re-formats them into its own language's sentence, so
+/// numbers pick up the reader's digit grouping instead of being frozen into a string here.
+///
+public sealed record ImportWarning(ImportWarningKind Kind, string Message, IReadOnlyList Args)
+{
+ /// Falls back to the English sentence, so a plain ToString() is still useful.
+ public override string ToString() => Message;
+}
+
+///
+/// Builds the warnings the CSV importer emits.
+///
+///
+/// Each kind has exactly one English format string here, and the arguments travel alongside the
+/// rendered sentence — so the importer stays free of any notion of who is reading, and the admin UI
+/// can say the same thing in German without this assembly growing a resource file.
+///
+internal static class ImportWarnings
+{
+ public static ImportWarning RowSkipped(int row, string reason) =>
+ Create(ImportWarningKind.RowSkipped, "Row {0}: skipped ({1}).", row, reason);
+
+ public static ImportWarning UnparseableDate(int row) =>
+ Create(ImportWarningKind.UnparseableDate, "Row {0}: unparseable date, skipped.", row);
+
+ public static ImportWarning UnitMismatch(int row, string expected, string found) =>
+ Create(ImportWarningKind.UnitMismatch, "Row {0}: expected unit '{1}' but found '{2}'.", row, expected, found);
+
+ public static ImportWarning RegisterDropped(int row, int meterId, double previous, double current) =>
+ Create(
+ ImportWarningKind.RegisterDropped,
+ "Row {0}: register for meter {1} dropped {2}→{3}; swap event created (verify).",
+ row, meterId, previous, current);
+
+ public static ImportWarning RegisterDroppedWithAmount(
+ int row, int meterId, double previous, double current, double amount) =>
+ Create(
+ ImportWarningKind.RegisterDroppedWithAmount,
+ "Row {0}: register for meter {1} dropped {2}→{3}; swap consumption set to {4}.",
+ row, meterId, previous, current, amount);
+
+ private static ImportWarning Create(ImportWarningKind kind, string format, params object?[] args) =>
+ new(kind, string.Format(CultureInfo.InvariantCulture, format, args), args);
+}
diff --git a/src/Infrastructure/Import/StagedImport.cs b/src/Infrastructure/Import/StagedImport.cs
index 6f1fae4..4b3aaeb 100644
--- a/src/Infrastructure/Import/StagedImport.cs
+++ b/src/Infrastructure/Import/StagedImport.cs
@@ -15,7 +15,7 @@ public sealed class StagedImport
public List ManualCosts { get; } = [];
- public List Warnings { get; } = [];
+ public List Warnings { get; } = [];
public int SkippedRows { get; set; }
diff --git a/src/Infrastructure/Ingestion/HaConnectionTester.cs b/src/Infrastructure/Ingestion/HaConnectionTester.cs
index 64a5b5d..92114d8 100644
--- a/src/Infrastructure/Ingestion/HaConnectionTester.cs
+++ b/src/Infrastructure/Ingestion/HaConnectionTester.cs
@@ -3,8 +3,55 @@ using Microsoft.Extensions.Logging;
namespace MeterVault.Infrastructure.Ingestion;
+/// Which way a Home Assistant connectivity test ended.
+///
+/// The verdict is shown to whoever clicked "Test connection", so it has to be sayable in their
+/// language — and this assembly has no business knowing what that is. The outcome travels as a
+/// value and the admin UI supplies the words.
+///
+public enum HaTestOutcome
+{
+ ///
+ /// No test was run — the caller decided beforehand (no token configured, base URL edited since
+ /// saving) and put its own, already-localized wording in .
+ /// The default, so a result built by the UI needs no ceremony to say so.
+ ///
+ Precondition,
+
+ /// Reachable and the token was accepted; no entity was named to sample.
+ Connected,
+
+ /// Reachable and the named entity returned a number — see .
+ ConnectedWithValue,
+
+ /// No base URL was given.
+ BaseUrlMissing,
+
+ /// No token was available to test with.
+ TokenMissing,
+
+ /// HA answered, but not with success. carries the status.
+ HttpError,
+
+ /// Reachable, but the named entity has no numeric state (unavailable/unknown/non-numeric).
+ NoNumericState,
+
+ /// The request threw. carries the exception message.
+ RequestFailed,
+}
+
/// Outcome of a Home Assistant connectivity test.
-public sealed record HaTestResult(bool Ok, string Message, double? SampleValue = null);
+/// The English summary, kept for logs and non-UI callers.
+/// The same verdict as a value, for a UI that has to phrase it in some language.
+/// The entity that was sampled, when one was named.
+/// Diagnostic text (HTTP status, exception message). Not ours to translate.
+public sealed record HaTestResult(
+ bool Ok,
+ string Message,
+ double? SampleValue = null,
+ HaTestOutcome Outcome = HaTestOutcome.Precondition,
+ string? EntityId = null,
+ string? Detail = null);
///
/// Verifies a Home Assistant connection from the admin UI: checks the base URL + token against
@@ -26,12 +73,12 @@ public sealed class HaConnectionTester(IHttpClientFactory httpClientFactory, ILo
{
if (string.IsNullOrWhiteSpace(baseUrl))
{
- return new HaTestResult(false, "Base URL is required.");
+ return new HaTestResult(false, "Base URL is required.", Outcome: HaTestOutcome.BaseUrlMissing);
}
if (string.IsNullOrWhiteSpace(token))
{
- return new HaTestResult(false, "No token available to test.");
+ return new HaTestResult(false, "No token available to test.", Outcome: HaTestOutcome.TokenMissing);
}
var client = _httpClientFactory.CreateClient();
@@ -44,23 +91,29 @@ public sealed class HaConnectionTester(IHttpClientFactory httpClientFactory, ILo
using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
- return new HaTestResult(false, $"HA returned {(int)response.StatusCode} {response.ReasonPhrase}.");
+ return new HaTestResult(false, $"HA returned {(int)response.StatusCode} {response.ReasonPhrase}.",
+ Outcome: HaTestOutcome.HttpError,
+ Detail: $"{(int)response.StatusCode} {response.ReasonPhrase}".Trim());
}
if (string.IsNullOrWhiteSpace(entityId))
{
- return new HaTestResult(true, "Connected — Home Assistant API reachable and token accepted.");
+ return new HaTestResult(true, "Connected — Home Assistant API reachable and token accepted.",
+ Outcome: HaTestOutcome.Connected);
}
var state = await new HaStateClient(client).GetStateAsync(baseUrl, token, entityId, null, cancellationToken).ConfigureAwait(false);
return state is { } value
- ? new HaTestResult(true, $"Connected — {entityId} = {value.Value}.", value.Value)
- : new HaTestResult(false, $"Connected, but '{entityId}' has no numeric state (unavailable/unknown or non-numeric).");
+ ? new HaTestResult(true, $"Connected — {entityId} = {value.Value}.", value.Value,
+ HaTestOutcome.ConnectedWithValue, entityId)
+ : new HaTestResult(false, $"Connected, but '{entityId}' has no numeric state (unavailable/unknown or non-numeric).",
+ Outcome: HaTestOutcome.NoNumericState, EntityId: entityId);
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Home Assistant connection test failed for {BaseUrl}", baseUrl);
- return new HaTestResult(false, $"Connection failed: {ex.Message}");
+ return new HaTestResult(false, $"Connection failed: {ex.Message}",
+ Outcome: HaTestOutcome.RequestFailed, Detail: ex.Message);
}
}
}
diff --git a/src/Infrastructure/Update/UpdateRunner.cs b/src/Infrastructure/Update/UpdateRunner.cs
index 82ac17e..a03251b 100644
--- a/src/Infrastructure/Update/UpdateRunner.cs
+++ b/src/Infrastructure/Update/UpdateRunner.cs
@@ -17,8 +17,43 @@ public enum UpdateAvailability
NotSupportedHere,
}
+/// Which way an attempt to launch the updater ended.
+///
+/// The UI needs to say this in the reader's language, and this assembly has no business knowing
+/// what that language is — so the outcome travels as a value and the wording is chosen upstairs.
+///
+public enum UpdateOutcome
+{
+ /// The transient unit is running; the service restarts when the rebuild finishes.
+ Started,
+
+ /// refused before anything was launched.
+ NotAllowed,
+
+ /// systemd-run could not be started at all.
+ LauncherMissing,
+
+ /// systemd-run ran and exited non-zero — most often an update already in flight.
+ LauncherFailed,
+
+ /// Launching threw. carries the exception message.
+ LaunchError,
+}
+
/// Outcome of trying to launch the updater.
-public sealed record UpdateLaunch(bool Started, string Message);
+///
+/// The English summary. Kept as-is for logs and any non-UI caller, so a translation can never change
+/// what an operator reads in a log line.
+///
+/// The same result as a value, for a UI that has to phrase it in some language.
+/// Why it was refused, when is .
+/// Diagnostic text (stderr, an exception message). Never translated — it isn't ours.
+public sealed record UpdateLaunch(
+ bool Started,
+ string Message,
+ UpdateOutcome Outcome = UpdateOutcome.LaunchError,
+ UpdateAvailability? Availability = null,
+ string? Detail = null);
///
/// Starts the in-container updater on request, gated hard.
@@ -75,7 +110,8 @@ public sealed class UpdateRunner(IOptions options, ILogger options, ILogger options, ILogger options, ILogger
+/// The language picker's endpoint and the culture the middleware hands each render (SDD §12, M7).
+///
+///
+///
+/// A Blazor Server circuit is fixed to the culture of the request that opened it, so switching
+/// language cannot be an interactive state change — it is a redirect that writes a cookie and forces
+/// a reload. That makes /culture/set a redirector taking its target from the query string,
+/// which is the exact shape of an open redirect, so the off-site cases below are load-bearing.
+///
+///
+/// Nothing here touches the database: no page on these paths queries, and startup migration is off,
+/// so the connection string only has to parse. They run without Docker.
+///
+///
+public sealed class CultureEndpointTests : IDisposable
+{
+ private const string UnusedConnection = "Host=localhost;Port=1;Database=metervault;Username=none;Password=none";
+
+ /// Renders the full layout (app bar + nav) without needing any data.
+ private static readonly Uri LayoutOnlyPage = new("/admin/settings", UriKind.Relative);
+
+ private readonly List _factories = [];
+
+ [Fact]
+ public async Task Setting_a_supported_culture_stores_the_cookie_and_returns_the_user_to_the_page()
+ {
+ using var client = RedirectlessClient();
+
+ using var response = await client.GetAsync(
+ new Uri("/culture/set?culture=de&redirectUri=%2Fmeters%2F7", UriKind.Relative));
+
+ Assert.Equal(HttpStatusCode.Found, response.StatusCode);
+ Assert.Equal("/meters/7", response.Headers.Location?.OriginalString);
+ Assert.Contains("c%3Dde%7Cuic%3Dde", CultureCookie(response), StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public async Task A_regional_variant_is_stored_as_the_language_we_ship()
+ {
+ using var client = RedirectlessClient();
+
+ using var response = await client.GetAsync(
+ new Uri("/culture/set?culture=de-AT&redirectUri=%2F", UriKind.Relative));
+
+ Assert.Equal(HttpStatusCode.Found, response.StatusCode);
+ Assert.Contains("c%3Dde%7Cuic%3Dde", CultureCookie(response), StringComparison.Ordinal);
+ }
+
+ [Theory]
+ [InlineData("fr")]
+ [InlineData("")]
+ [InlineData("../../etc/passwd")]
+ public async Task A_language_we_do_not_ship_is_refused_rather_than_stored(string culture)
+ {
+ using var client = RedirectlessClient();
+
+ using var response = await client.GetAsync(
+ new Uri($"/culture/set?culture={Uri.EscapeDataString(culture)}&redirectUri=%2F", UriKind.Relative));
+
+ Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+ Assert.Null(CultureCookie(response));
+ }
+
+ [Theory]
+ [InlineData("https://evil.example/phish")]
+ [InlineData("//evil.example/phish")]
+ [InlineData("/\\evil.example/phish")]
+ [InlineData("")]
+ public async Task An_off_site_redirect_target_lands_on_the_dashboard_instead(string redirectUri)
+ {
+ using var client = RedirectlessClient();
+
+ using var response = await client.GetAsync(
+ new Uri($"/culture/set?culture=de&redirectUri={Uri.EscapeDataString(redirectUri)}", UriKind.Relative));
+
+ Assert.Equal(HttpStatusCode.Found, response.StatusCode);
+ Assert.Equal("/", response.Headers.Location?.OriginalString);
+ }
+
+ [Fact]
+ public async Task The_culture_cookie_decides_the_language_of_the_rendered_page()
+ {
+ using var client = Factory().CreateClient();
+ client.DefaultRequestHeaders.Add(
+ "Cookie",
+ CookieRequestCultureProvider.DefaultCookieName
+ + "="
+ + Uri.EscapeDataString(CookieRequestCultureProvider.MakeCookieValue(new RequestCulture("de"))));
+
+ var html = await RenderedTextAsync(client, LayoutOnlyPage);
+
+ Assert.Contains("lang=\"de\"", html, StringComparison.Ordinal);
+ Assert.Contains("Übersicht", html, StringComparison.Ordinal);
+ Assert.DoesNotContain("Overview", html, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public async Task Without_a_cookie_the_instance_default_locale_applies()
+ {
+ using var client = Factory(locale: "de").CreateClient();
+
+ var html = await RenderedTextAsync(client, LayoutOnlyPage);
+
+ Assert.Contains("lang=\"de\"", html, StringComparison.Ordinal);
+ Assert.Contains("Übersicht", html, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public async Task English_is_the_shipped_default_when_nothing_is_configured()
+ {
+ using var client = Factory().CreateClient();
+
+ var html = await RenderedTextAsync(client, LayoutOnlyPage);
+
+ Assert.Contains("lang=\"en\"", html, StringComparison.Ordinal);
+ Assert.Contains("Overview", html, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public async Task An_unshipped_default_locale_degrades_to_english_instead_of_failing_to_boot()
+ {
+ using var client = Factory(locale: "fr").CreateClient();
+
+ var html = await RenderedTextAsync(client, LayoutOnlyPage);
+
+ Assert.Contains("lang=\"en\"", html, StringComparison.Ordinal);
+ Assert.Contains("Overview", html, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public async Task The_first_visit_pins_the_negotiated_culture_into_the_cookie()
+ {
+ // Otherwise a reader whose browser asks for German is served German, but opens the picker
+ // to find English ticked — the cookie is the only thing either side agrees to read.
+ using var client = RedirectlessClient();
+ client.DefaultRequestHeaders.Add("Accept-Language", "de-DE,de;q=0.9,en;q=0.8");
+
+ using var response = await client.GetAsync(LayoutOnlyPage);
+
+ Assert.Contains("c%3Dde%7Cuic%3Dde", CultureCookie(response), StringComparison.Ordinal);
+ }
+
+ public void Dispose()
+ {
+ foreach (var factory in _factories)
+ {
+ factory.Dispose();
+ }
+ }
+
+ ///
+ /// Blazor entity-encodes every non-ASCII character it renders, so "Übersicht" arrives as
+ /// "Übersicht" — decoding first is what lets these assertions read like the UI does.
+ ///
+ private static async Task RenderedTextAsync(HttpClient client, Uri page) =>
+ WebUtility.HtmlDecode(await client.GetStringAsync(page));
+
+ private static string? CultureCookie(HttpResponseMessage response) =>
+ response.Headers.TryGetValues("Set-Cookie", out var cookies)
+ ? cookies.FirstOrDefault(c =>
+ c.StartsWith(CookieRequestCultureProvider.DefaultCookieName, StringComparison.Ordinal))
+ : null;
+
+ private MeterVaultAppFactory Factory(string? locale = null)
+ {
+ var factory = new MeterVaultAppFactory(UnusedConnection, configureApiKey: false) { Locale = locale };
+ _factories.Add(factory);
+ return factory;
+ }
+
+ private HttpClient RedirectlessClient() =>
+ Factory().CreateClient(new WebApplicationFactoryClientOptions { AllowAutoRedirect = false });
+}
diff --git a/tests/Integration.Tests/Localization/EnumDisplayNameTests.cs b/tests/Integration.Tests/Localization/EnumDisplayNameTests.cs
new file mode 100644
index 0000000..53e93f1
--- /dev/null
+++ b/tests/Integration.Tests/Localization/EnumDisplayNameTests.cs
@@ -0,0 +1,119 @@
+using System.Globalization;
+using MeterVault.App.Localization;
+using MeterVault.Core.Domain;
+
+namespace MeterVault.Integration.Tests.Localization;
+
+///
+/// Every domain enum value the UI renders has wording in every language (SDD §12, M7).
+///
+///
+/// ends each mapping with a fallback arm that returns the bare identifier,
+/// so adding an enum value can never throw mid-render on a dashboard. The cost of that safety is that
+/// a forgotten value degrades silently to English — these tests are what make it loud instead, by
+/// demanding a matching Enum_<Type>_<Value> resource for every declared value.
+///
+public sealed class EnumDisplayNameTests
+{
+ [Fact]
+ public void Every_localized_enum_value_has_a_resource_in_every_language()
+ {
+ var missing = new List();
+
+ foreach (var type in DisplayNames.LocalizedEnums)
+ {
+ foreach (var name in Enum.GetNames(type))
+ {
+ // None is the empty bitmask, deliberately rendered as nothing at all.
+ if (type == typeof(ReadingFlags) && name == nameof(ReadingFlags.None))
+ {
+ continue;
+ }
+
+ var key = $"Enum_{type.Name}_{name}";
+ foreach (var culture in Loc.SupportedCultures)
+ {
+ var value = Strings.ResourceManager.GetString(key, CultureInfo.GetCultureInfo(culture));
+ if (string.IsNullOrWhiteSpace(value))
+ {
+ missing.Add($"{key} [{culture}]");
+ }
+ }
+ }
+ }
+
+ Assert.True(missing.Count == 0, $"Missing enum display names: {string.Join(", ", missing)}");
+ }
+
+ [Fact]
+ public void Display_names_are_translated_rather_than_echoing_the_identifier()
+ {
+ // Not every value can differ — "Tasmota", "Bonus" and "Global" are the same word in German —
+ // but if a whole enum came back as its own identifiers, the mapping was never written.
+ var untranslated = new List();
+
+ foreach (var type in DisplayNames.LocalizedEnums)
+ {
+ var names = Enum.GetNames(type);
+ var translated = 0;
+ foreach (var name in names)
+ {
+ var german = Strings.ResourceManager.GetString($"Enum_{type.Name}_{name}", CultureInfo.GetCultureInfo("de"));
+ if (german is not null && !string.Equals(german, name, StringComparison.Ordinal))
+ {
+ translated++;
+ }
+ }
+
+ if (translated == 0)
+ {
+ untranslated.Add(type.Name);
+ }
+ }
+
+ Assert.True(untranslated.Count == 0, $"Enums with no German wording at all: {string.Join(", ", untranslated)}");
+ }
+
+ [Theory]
+ [InlineData("en", "Consumption")]
+ [InlineData("de", "Verbrauch")]
+ public void The_reader_s_language_decides_the_wording(string culture, string expected) =>
+ Assert.Equal(expected, WithUiCulture(culture, () => ConsumptionKind.Consumption.Display()));
+
+ [Fact]
+ public void A_bitmask_lists_the_flags_it_actually_carries()
+ {
+ // Blank rather than "None": the readings table has a flag column that is empty on almost
+ // every row, and printing a word down the whole page is noise, not information.
+ Assert.Equal(string.Empty, ReadingFlags.None.Display());
+
+ var both = WithUiCulture("de", () => (ReadingFlags.CounterReset | ReadingFlags.MeterSwap).Display());
+ Assert.Equal("Zählerreset, Zählerwechsel", both);
+
+ Assert.Equal("Meter swap", WithUiCulture("en", () => ReadingFlags.MeterSwap.Display()));
+ }
+
+ [Fact]
+ public void An_undeclared_enum_value_degrades_to_its_identifier_instead_of_throwing()
+ {
+ // Guards the fallback arm itself: a value cast in from the database (or a future migration)
+ // must not take a dashboard down.
+ var unknown = (MeterMode)999;
+
+ Assert.Equal("999", unknown.Display());
+ }
+
+ private static T WithUiCulture(string culture, Func body)
+ {
+ var previous = CultureInfo.CurrentUICulture;
+ try
+ {
+ CultureInfo.CurrentUICulture = CultureInfo.GetCultureInfo(culture);
+ return body();
+ }
+ finally
+ {
+ CultureInfo.CurrentUICulture = previous;
+ }
+ }
+}
diff --git a/tests/Integration.Tests/Localization/FormatCultureTests.cs b/tests/Integration.Tests/Localization/FormatCultureTests.cs
new file mode 100644
index 0000000..58642ef
--- /dev/null
+++ b/tests/Integration.Tests/Localization/FormatCultureTests.cs
@@ -0,0 +1,80 @@
+using System.Globalization;
+using MeterVault.App;
+
+namespace MeterVault.Integration.Tests.Localization;
+
+///
+/// formats against the reader's culture rather than a fixed de-DE (SDD §12, M7).
+///
+///
+/// The importer's de-DE parsing is deliberately untouched by this: that dialect is a property of the
+/// spreadsheet files, not of who is looking at the dashboard, and GermanParsingTests pins it.
+///
+public sealed class FormatCultureTests
+{
+ [Fact]
+ public void Digit_grouping_follows_the_reader()
+ {
+ Assert.Equal("1.234,5", WithCulture("de", () => Format.Number(1234.5, 1)));
+ Assert.Equal("1,234.5", WithCulture("en", () => Format.Number(1234.5, 1)));
+
+ Assert.Equal("2.940", WithCulture("de", () => Format.Number(2940)));
+ Assert.Equal("2,940", WithCulture("en", () => Format.Number(2940)));
+ }
+
+ [Fact]
+ public void The_currency_symbol_stays_the_instances_own()
+ {
+ // Only the grouping is localized. The figures are in the instance's configured currency, so
+ // an English reader must see the same money written their way — not relabelled as dollars.
+ Assert.Equal("1.234,50 €", WithCulture("de", () => Format.Euro(1234.5)));
+ Assert.Equal("1,234.50 €", WithCulture("en", () => Format.Euro(1234.5)));
+ }
+
+ [Fact]
+ public void Percentages_keep_their_explicit_sign()
+ {
+ Assert.Equal("+12,4 %", WithCulture("de", () => Format.Percent(12.4)));
+ Assert.Equal("+12.4 %", WithCulture("en", () => Format.Percent(12.4)));
+
+ Assert.Equal("-7,2 %", WithCulture("de", () => Format.Percent(-7.2)));
+ Assert.Equal("-7.2 %", WithCulture("en", () => Format.Percent(-7.2)));
+ }
+
+ [Fact]
+ public void Month_labels_are_written_in_the_readers_language()
+ {
+ var march = new DateOnly(2025, 3, 1);
+
+ var german = WithCulture("de", () => Format.MonthLabel(march));
+ var english = WithCulture("en", () => Format.MonthLabel(march));
+
+ // Asserting the exact German abbreviation would pin us to one ICU version ("Mrz" vs "Mär"),
+ // so assert what actually matters: the label is culture-sensitive, not invariant.
+ Assert.Equal("Mar 25", english);
+ Assert.NotEqual(english, german);
+ Assert.EndsWith("25", german, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Direction_icons_are_language_neutral()
+ {
+ Assert.Equal("▲", Format.DirectionIcon(1));
+ Assert.Equal("▼", Format.DirectionIcon(-1));
+ Assert.Equal("—", Format.DirectionIcon(0));
+ }
+
+ private static T WithCulture(string culture, Func body)
+ {
+ var previous = CultureInfo.CurrentCulture;
+ try
+ {
+ CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(culture);
+ return body();
+ }
+ finally
+ {
+ CultureInfo.CurrentCulture = previous;
+ }
+ }
+}
diff --git a/tests/Integration.Tests/Localization/StringResourceTests.cs b/tests/Integration.Tests/Localization/StringResourceTests.cs
new file mode 100644
index 0000000..3add918
--- /dev/null
+++ b/tests/Integration.Tests/Localization/StringResourceTests.cs
@@ -0,0 +1,220 @@
+using System.Collections;
+using System.Globalization;
+using System.Reflection;
+using System.Resources;
+using System.Text.RegularExpressions;
+using MeterVault.App.Localization;
+
+namespace MeterVault.Integration.Tests.Localization;
+
+///
+/// Guards the UI string catalogue (SDD §12, M7).
+///
+///
+/// Resource lookup fails soft by design — ask for a key the German satellite doesn't carry and
+/// quietly serves the English one. That is the right runtime
+/// behaviour and the wrong build behaviour: a half-translated release would look perfectly healthy.
+/// These tests read each culture's resource set with tryParents: false, which is the only way
+/// to see what a satellite actually contains, and turn "untranslated" back into a failure.
+/// No database, so they run without Docker.
+///
+public sealed class StringResourceTests
+{
+ /// Matches {0}, {1:N2}, {0,-8} — the index is what has to agree across languages.
+ private static readonly Regex PlaceholderPattern = new(@"\{(\d+)(?:[,:][^}]*)?\}", RegexOptions.Compiled);
+
+ private static readonly IReadOnlyDictionary Neutral = ResourcesFor(CultureInfo.InvariantCulture);
+
+ [Fact]
+ public void Neutral_resources_exist()
+ {
+ Assert.NotEmpty(Neutral);
+
+ // Every generated property is backed by a real entry, so `S.Foo` can never compile against
+ // a key the resx no longer defines.
+ var generated = typeof(Strings)
+ .GetProperties(BindingFlags.Public | BindingFlags.Static)
+ .Where(p => p.PropertyType == typeof(string) && p.Name != "Culture")
+ .Select(p => p.Name)
+ .ToList();
+
+ Assert.NotEmpty(generated);
+ Assert.Empty(generated.Except(Neutral.Keys, StringComparer.Ordinal));
+ }
+
+ [Theory]
+ [MemberData(nameof(TranslatedCultures))]
+ public void Every_string_is_translated(string culture)
+ {
+ var translated = ResourcesFor(CultureInfo.GetCultureInfo(culture));
+
+ var missing = Neutral.Keys.Except(translated.Keys, StringComparer.Ordinal).Order(StringComparer.Ordinal).ToList();
+ Assert.True(
+ missing.Count == 0,
+ $"Strings.{culture}.resx is missing {missing.Count} key(s): {string.Join(", ", missing)}");
+
+ // An entry that exists but is blank renders as nothing at all — worse than falling back.
+ var blank = translated.Where(e => string.IsNullOrWhiteSpace(e.Value)).Select(e => e.Key).Order(StringComparer.Ordinal).ToList();
+ Assert.True(blank.Count == 0, $"Strings.{culture}.resx has blank value(s): {string.Join(", ", blank)}");
+ }
+
+ [Theory]
+ [MemberData(nameof(TranslatedCultures))]
+ public void No_translation_is_orphaned(string culture)
+ {
+ var translated = ResourcesFor(CultureInfo.GetCultureInfo(culture));
+
+ // A key only the translation has is dead weight: nothing can reference it, because the
+ // strongly-typed accessor is generated from the neutral resx alone.
+ var orphans = translated.Keys.Except(Neutral.Keys, StringComparer.Ordinal).Order(StringComparer.Ordinal).ToList();
+ Assert.True(
+ orphans.Count == 0,
+ $"Strings.{culture}.resx defines {orphans.Count} key(s) the neutral resx does not: {string.Join(", ", orphans)}");
+ }
+
+ [Theory]
+ [MemberData(nameof(TranslatedCultures))]
+ public void Placeholders_survive_translation(string culture)
+ {
+ var translated = ResourcesFor(CultureInfo.GetCultureInfo(culture));
+
+ // Loc.F feeds these to string.Format, so a placeholder dropped or invented in translation is
+ // a FormatException or a silently missing number at runtime, in that language only.
+ var broken = new List();
+ foreach (var (key, english) in Neutral)
+ {
+ if (!translated.TryGetValue(key, out var other))
+ {
+ continue;
+ }
+
+ var expected = PlaceholderIndexes(english);
+ var actual = PlaceholderIndexes(other);
+ if (!expected.SetEquals(actual))
+ {
+ broken.Add($"{key} (en: {{{string.Join(",", expected.Order())}}}, {culture}: {{{string.Join(",", actual.Order())}}})");
+ }
+ }
+
+ Assert.True(broken.Count == 0, $"Placeholder mismatch in Strings.{culture}.resx: {string.Join("; ", broken)}");
+ }
+
+ [Fact]
+ public void Supported_cultures_all_resolve()
+ {
+ foreach (var culture in Loc.SupportedCultures)
+ {
+ Assert.True(Loc.TryResolve(culture, out var resolved));
+ Assert.Equal(culture, resolved);
+
+ // The picker labels itself with these, so an unnamed culture would render blank.
+ Assert.False(string.IsNullOrWhiteSpace(Loc.DisplayName(culture)));
+ }
+ }
+
+ [Theory]
+ [InlineData("de-DE", "de")]
+ [InlineData("de-AT", "de")]
+ [InlineData("de_CH", "de")]
+ [InlineData("EN-gb", "en")]
+ public void Regional_variants_resolve_to_the_language_we_ship(string requested, string expected)
+ {
+ Assert.True(Loc.TryResolve(requested, out var resolved));
+ Assert.Equal(expected, resolved);
+ }
+
+ [Theory]
+ [InlineData(null)]
+ [InlineData("")]
+ [InlineData(" ")]
+ [InlineData("fr")]
+ [InlineData("klingon")]
+ public void Untranslated_languages_fall_back_to_the_neutral_culture(string? requested)
+ {
+ Assert.False(Loc.TryResolve(requested, out var resolved));
+ Assert.Equal(Loc.SupportedCultures[0], resolved);
+ }
+
+ [Fact]
+ public void No_string_is_defined_but_never_used()
+ {
+ // The compiler catches the other direction — S.Foo against a deleted key is a build error —
+ // but a key nothing references compiles perfectly and quietly costs a translator work on
+ // every language we ever add. Enum_* is exempt: those are reached by name from
+ // DisplayNames' switch arms, which EnumDisplayNameTests covers instead.
+ var root = FindRepositoryRoot();
+ if (root is null)
+ {
+ return; // Running detached from the source tree; the other tests still cover the catalogue.
+ }
+
+ var sources = new[] { Path.Combine(root, "src") }
+ .SelectMany(dir => Directory.EnumerateFiles(dir, "*.*", SearchOption.AllDirectories))
+ .Where(f => (f.EndsWith(".cs", StringComparison.Ordinal) || f.EndsWith(".razor", StringComparison.Ordinal))
+ && !f.Contains($"{Path.DirectorySeparatorChar}obj{Path.DirectorySeparatorChar}", StringComparison.Ordinal))
+ .Select(File.ReadAllText)
+ .ToList();
+
+ Assert.NotEmpty(sources);
+ var all = string.Join('\n', sources);
+
+ var unused = Neutral.Keys
+ .Where(k => !k.StartsWith("Enum_", StringComparison.Ordinal))
+ .Where(k => !Regex.IsMatch(all, $@"\b{Regex.Escape(k)}\b"))
+ .Order(StringComparer.Ordinal)
+ .ToList();
+
+ Assert.True(unused.Count == 0, $"{unused.Count} unused string(s): {string.Join(", ", unused)}");
+ }
+
+ /// Walks up from the test binaries to the checkout, identified by the solution file.
+ private static string? FindRepositoryRoot()
+ {
+ var dir = new DirectoryInfo(AppContext.BaseDirectory);
+ while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "MeterVault.slnx")))
+ {
+ dir = dir.Parent;
+ }
+
+ return dir?.FullName;
+ }
+
+ /// Every shipped language except the neutral one, which is the baseline being compared against.
+ public static TheoryData TranslatedCultures()
+ {
+ var data = new TheoryData();
+ foreach (var culture in Loc.SupportedCultures.Skip(1))
+ {
+ data.Add(culture);
+ }
+
+ return data;
+ }
+
+ private static HashSet PlaceholderIndexes(string value) =>
+ [.. PlaceholderPattern.Matches(value).Select(m => int.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture))];
+
+ ///
+ /// The entries one culture's resource set actually defines. tryParents: false is the
+ /// whole point: with fallback on, a missing German string is indistinguishable from a present one.
+ ///
+ private static IReadOnlyDictionary ResourcesFor(CultureInfo culture)
+ {
+ var set = Strings.ResourceManager.GetResourceSet(culture, createIfNotExists: true, tryParents: false);
+ var entries = new Dictionary(StringComparer.Ordinal);
+ if (set is null)
+ {
+ return entries;
+ }
+
+ foreach (DictionaryEntry entry in set)
+ {
+ if (entry.Key is string key && entry.Value is string value)
+ {
+ entries[key] = value;
+ }
+ }
+
+ return entries;
+ }
+}
diff --git a/tests/Integration.Tests/MeterPeriodServiceTests.cs b/tests/Integration.Tests/MeterPeriodServiceTests.cs
index 34d8869..7adb614 100644
--- a/tests/Integration.Tests/MeterPeriodServiceTests.cs
+++ b/tests/Integration.Tests/MeterPeriodServiceTests.cs
@@ -30,7 +30,7 @@ public sealed class MeterPeriodServiceTests(TimescaleFixture fx)
var view = await NewService().GetAsync(meterId);
Assert.NotNull(view);
- Assert.Equal("Consumption", view!.Label);
+ Assert.Equal(ConsumptionKind.Consumption, view!.Kind);
Assert.Equal(30d, view.MonthToDate, 3);
Assert.Equal(100d, view.LastMonth, 3);
Assert.Equal(130d, view.YearToDate, 3);
@@ -55,7 +55,7 @@ public sealed class MeterPeriodServiceTests(TimescaleFixture fx)
var view = await NewService().GetAsync(meterId);
Assert.NotNull(view);
- Assert.Equal("Generation", view!.Label);
+ Assert.Equal(ConsumptionKind.Generation, view!.Kind);
Assert.Equal(42d, view.MonthToDate, 3);
await CleanupAsync(db, meterId);
diff --git a/tests/Integration.Tests/MeterVaultAppFactory.cs b/tests/Integration.Tests/MeterVaultAppFactory.cs
index 4ecc78c..86216fd 100644
--- a/tests/Integration.Tests/MeterVaultAppFactory.cs
+++ b/tests/Integration.Tests/MeterVaultAppFactory.cs
@@ -11,8 +11,16 @@ public sealed class MeterVaultAppFactory(string connectionString, bool configure
{
public const string ApiKey = "test-api-key";
+ /// Overrides MeterVault__Locale, the instance's default UI language.
+ public string? Locale { get; init; }
+
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
+ if (Locale is not null)
+ {
+ builder.UseSetting("MeterVault:Locale", Locale);
+ }
+
builder.UseEnvironment("Testing");
builder.UseSetting("ConnectionStrings:Default", connectionString);
builder.UseSetting("MeterVault:RunMigrationsAtStartup", "false");