1563 lines
58 KiB
C#
1563 lines
58 KiB
C#
using System.Globalization;
|
||
using System.Net;
|
||
using ClosedXML.Excel;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.VisualBasic.FileIO;
|
||
using TrafagSalesExporter.Data;
|
||
using TrafagSalesExporter.Models;
|
||
using TrafagSalesExporter.Services;
|
||
using TrafagSalesExporter.Services.DataSources;
|
||
|
||
var builder = WebApplication.CreateBuilder(args);
|
||
builder.Logging.ClearProviders();
|
||
builder.Logging.AddConsole();
|
||
|
||
var databasePath = ResolveDatabasePath(builder.Configuration["FinanceProbe:DatabasePath"]);
|
||
builder.Services.AddDbContextFactory<AppDbContext>(options =>
|
||
options.UseSqlite($"Data Source={databasePath};Default Timeout=60"));
|
||
builder.Services.AddHttpClient(nameof(ExchangeRateImportService));
|
||
builder.Services.AddSingleton<IHanaQueryService, HanaQueryService>();
|
||
builder.Services.AddSingleton<IExcelExportService, ExcelExportService>();
|
||
builder.Services.AddSingleton<ISharePointUploadService, SharePointUploadService>();
|
||
builder.Services.AddSingleton<ISapGatewayService, SapGatewayService>();
|
||
builder.Services.AddSingleton<IMappedSalesRecordComposer, MappedSalesRecordComposer>();
|
||
builder.Services.AddSingleton<ISapCompositionService, SapCompositionService>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, CopyTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, UppercaseTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, LowercaseTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, PrefixTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, SuffixTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, ReplaceTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, ConstantTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationStrategy, NormalizeCurrencyCodeTransformationStrategy>();
|
||
builder.Services.AddSingleton<ICurrencyExchangeRateService, CurrencyExchangeRateService>();
|
||
builder.Services.AddSingleton<IExchangeRateImportService, ExchangeRateImportService>();
|
||
builder.Services.AddSingleton<IRecordTransformationStrategy, FirstNonEmptyRecordTransformationStrategy>();
|
||
builder.Services.AddSingleton<IRecordTransformationStrategy, ConvertCurrencyRecordTransformationStrategy>();
|
||
builder.Services.AddSingleton<ITransformationCatalog, TransformationCatalog>();
|
||
builder.Services.AddSingleton<IRecordTransformationService, RecordTransformationService>();
|
||
builder.Services.AddSingleton<IAppEventLogService, AppEventLogService>();
|
||
builder.Services.AddSingleton<IManagementCockpitService, ManagementCockpitService>();
|
||
builder.Services.AddSingleton<IManualExcelImportService, ManualExcelImportService>();
|
||
builder.Services.AddSingleton<IConsolidatedExportService, ConsolidatedExportService>();
|
||
builder.Services.AddSingleton<IExportLogService, ExportLogService>();
|
||
builder.Services.AddSingleton<ICentralSalesRecordService, CentralSalesRecordService>();
|
||
builder.Services.AddSingleton<IConfigTransferService, ConfigTransferService>();
|
||
builder.Services.AddSingleton<IFinanceReconciliationService, FinanceReconciliationService>();
|
||
builder.Services.AddSingleton<IDataSourceAdapter, HanaDataSourceAdapter>();
|
||
builder.Services.AddSingleton<IDataSourceAdapter, SapGatewayDataSourceAdapter>();
|
||
builder.Services.AddSingleton<IDataSourceAdapter, ManualExcelDataSourceAdapter>();
|
||
builder.Services.AddSingleton<IDataSourceAdapterResolver, DataSourceAdapterResolver>();
|
||
builder.Services.AddSingleton<ISiteExportService, SiteExportService>();
|
||
builder.Services.AddSingleton<ExportOrchestrationService>();
|
||
|
||
var app = builder.Build();
|
||
|
||
app.MapGet("/", () => Results.Redirect("/finance"));
|
||
app.MapGet("/finance", async (IFinanceReconciliationService finance, IDbContextFactory<AppDbContext> dbFactory) =>
|
||
{
|
||
var rows = await finance.BuildNetSalesReferenceRowsAsync(2025);
|
||
var excelReferences = LoadCheckedExcelReferences(ResolveCheckedExcelPath());
|
||
var spainCsv = LoadSpainSalesCsvProbe(ResolveSpainSalesCsvPath());
|
||
var germanySample = LoadGermanyExcelProbe(ResolveGermanySamplePath());
|
||
var coverage = await LoadSiteCoverageAsync(dbFactory, 2025);
|
||
return Results.Content(BuildPage(rows, databasePath, excelReferences, spainCsv, germanySample, coverage), "text/html; charset=utf-8");
|
||
});
|
||
app.MapGet("/run/export-all", async (ExportOrchestrationService exports, IFinanceReconciliationService finance, IDbContextFactory<AppDbContext> dbFactory) =>
|
||
{
|
||
var startedAt = DateTime.Now;
|
||
await exports.ExportAllAsync();
|
||
var summary = await BuildRunSummaryAsync(finance, dbFactory, startedAt, "Alle aktiven Standorte exportiert und zentrale Datei erzeugt.");
|
||
return Results.Content(summary, "text/html; charset=utf-8");
|
||
});
|
||
app.MapGet("/run/consolidated", async (ExportOrchestrationService exports, IFinanceReconciliationService finance, IDbContextFactory<AppDbContext> dbFactory) =>
|
||
{
|
||
var startedAt = DateTime.Now;
|
||
var path = await exports.ExportConsolidatedOnlyAsync();
|
||
var message = string.IsNullOrWhiteSpace(path)
|
||
? "Zentrale Datei wurde nicht erzeugt; vermutlich keine CentralSalesRecords vorhanden oder Export lief bereits."
|
||
: $"Zentrale Datei erzeugt: {path}";
|
||
var summary = await BuildRunSummaryAsync(finance, dbFactory, startedAt, message);
|
||
return Results.Content(summary, "text/html; charset=utf-8");
|
||
});
|
||
app.MapGet("/run/export/{siteKey}", async (string siteKey, int? year, ExportOrchestrationService exports, IFinanceReconciliationService finance, IDbContextFactory<AppDbContext> dbFactory) =>
|
||
{
|
||
var startedAt = DateTime.Now;
|
||
var site = await ResolveSiteAsync(dbFactory, siteKey);
|
||
if (site is null)
|
||
return Results.NotFound($"Standort nicht gefunden: {siteKey}");
|
||
|
||
var importYear = year ?? 2025;
|
||
var result = await exports.ExportSiteByIdAsync(site.Id, importYear);
|
||
var message = result is null
|
||
? $"Export wurde nicht gestartet: {site.Land} / {site.TSC}"
|
||
: $"Export {result.Log.Status}: {site.Land} / {site.TSC}, Jahr={importYear}, Zeilen={result.Log.RowCount}, Datei={result.FilePath ?? "-"}, Fehler={result.Log.ErrorMessage}";
|
||
var summary = await BuildRunSummaryAsync(finance, dbFactory, startedAt, message);
|
||
return Results.Content(summary, "text/html; charset=utf-8");
|
||
});
|
||
|
||
app.Run();
|
||
|
||
static async Task<Site?> ResolveSiteAsync(IDbContextFactory<AppDbContext> dbFactory, string siteKey)
|
||
{
|
||
await using var db = await dbFactory.CreateDbContextAsync();
|
||
var normalized = siteKey.Trim();
|
||
if (int.TryParse(normalized, out var siteId))
|
||
return await db.Sites.AsNoTracking().FirstOrDefaultAsync(s => s.Id == siteId);
|
||
|
||
var sites = await db.Sites
|
||
.AsNoTracking()
|
||
.OrderBy(s => s.Id)
|
||
.ToListAsync();
|
||
return sites.FirstOrDefault(s =>
|
||
s.TSC.Equals(normalized, StringComparison.OrdinalIgnoreCase) ||
|
||
s.Land.Equals(normalized, StringComparison.OrdinalIgnoreCase));
|
||
}
|
||
|
||
static async Task<string> BuildRunSummaryAsync(
|
||
IFinanceReconciliationService finance,
|
||
IDbContextFactory<AppDbContext> dbFactory,
|
||
DateTime startedAt,
|
||
string message)
|
||
{
|
||
var rows = await finance.BuildNetSalesReferenceRowsAsync(2025);
|
||
var coverage = await LoadSiteCoverageAsync(dbFactory, 2025);
|
||
var recentLogs = await LoadRecentExportLogsAsync(dbFactory, startedAt);
|
||
var okCount = rows.Count(r => r.Status == "OK");
|
||
var checkCount = rows.Count(r => r.Status == "Pruefen");
|
||
var missingCount = rows.Count(r => r.Status == "Keine Daten");
|
||
var financeRows = string.Join(Environment.NewLine, rows.Select(row => $$"""
|
||
<tr>
|
||
<td>{{Html(row.Status)}}</td>
|
||
<td>{{Html(row.Key)}}</td>
|
||
<td>{{Html(row.Label)}}</td>
|
||
<td class="num">{{Amount(row.ActualValue)}}</td>
|
||
<td class="num">{{Amount(row.ReferenceValue)}}</td>
|
||
<td class="num">{{Amount(row.Difference)}}</td>
|
||
<td>{{Html(row.ValueField)}}</td>
|
||
<td class="num">{{row.RowCount}}</td>
|
||
</tr>
|
||
"""));
|
||
var coverageRows = string.Join(Environment.NewLine, coverage.Select(row => $$"""
|
||
<tr>
|
||
<td>{{Html(row.Land)}}<div class="small">{{Html(row.Tsc)}}</div></td>
|
||
<td>{{Html(row.SourceSystem)}}</td>
|
||
<td class="num">{{row.RowCount}}</td>
|
||
<td class="num">{{Amount(row.SalesPriceValue)}}</td>
|
||
<td>{{Html(row.Currencies)}}</td>
|
||
<td>{{Html(row.LastExportStatus)}}</td>
|
||
<td class="wrap">{{Html(row.LastExportError)}}</td>
|
||
</tr>
|
||
"""));
|
||
var logRows = string.Join(Environment.NewLine, recentLogs.Select(log => $$"""
|
||
<tr>
|
||
<td>{{Html(log.Timestamp.ToString("dd.MM.yyyy HH:mm:ss", CultureInfo.GetCultureInfo("de-CH")))}}</td>
|
||
<td>{{Html(log.Land)}}</td>
|
||
<td>{{Html(log.TSC)}}</td>
|
||
<td>{{Html(log.Status)}}</td>
|
||
<td class="num">{{log.RowCount}}</td>
|
||
<td>{{Html(log.FileName)}}</td>
|
||
<td class="wrap">{{Html(log.ErrorMessage)}}</td>
|
||
</tr>
|
||
"""));
|
||
|
||
return $$"""
|
||
<!doctype html>
|
||
<html lang="de">
|
||
<head>
|
||
<meta charset="utf-8">
|
||
<title>FinanceProbe Run Summary</title>
|
||
<style>
|
||
body { font-family: "Segoe UI", Arial, sans-serif; margin: 24px; background:#f6f7f9; color:#172033; }
|
||
.panel { background:#fff; border:1px solid #d8dee8; border-radius:6px; padding:14px; margin-bottom:14px; }
|
||
table { width:100%; border-collapse:collapse; background:#fff; border:1px solid #d8dee8; margin-top:8px; }
|
||
th { background:#22324a; color:#fff; text-align:left; padding:7px 9px; }
|
||
td { border-top:1px solid #d8dee8; padding:6px 9px; vertical-align:top; }
|
||
.num { text-align:right; font-variant-numeric:tabular-nums; }
|
||
.small { color:#667085; font-size:12px; }
|
||
.wrap { max-width:520px; }
|
||
a { color:#1f4f7a; }
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<section class="panel">
|
||
<h1>FinanceProbe Run Summary</h1>
|
||
<p>{{Html(message)}}</p>
|
||
<p class="small">Start: {{Html(startedAt.ToString("dd.MM.yyyy HH:mm:ss", CultureInfo.GetCultureInfo("de-CH")))}} | Ergebnis: OK={{okCount}}, Pruefen={{checkCount}}, Keine Daten={{missingCount}}</p>
|
||
<p><a href="/finance">Zur Finance-Auswertung</a> | <a href="/run/consolidated">Zentrale Datei erzeugen</a> | <a href="/run/export-all">Alle exportieren</a></p>
|
||
</section>
|
||
<section class="panel">
|
||
<h2>Neue Exportlogs seit Start</h2>
|
||
<table><thead><tr><th>Zeit</th><th>Land</th><th>TSC</th><th>Status</th><th class="num">Zeilen</th><th>Datei</th><th>Fehler</th></tr></thead><tbody>{{logRows}}</tbody></table>
|
||
</section>
|
||
<section class="panel">
|
||
<h2>Finance-Abgleich</h2>
|
||
<table><thead><tr><th>Status</th><th>Key</th><th>Label</th><th class="num">Ist</th><th class="num">Soll</th><th class="num">Diff</th><th>Feld</th><th class="num">Zeilen</th></tr></thead><tbody>{{financeRows}}</tbody></table>
|
||
</section>
|
||
<section class="panel">
|
||
<h2>Datenabdeckung</h2>
|
||
<table><thead><tr><th>Standort</th><th>System</th><th class="num">Zeilen</th><th class="num">Sales</th><th>Waehrung</th><th>Letzter Status</th><th>Fehler</th></tr></thead><tbody>{{coverageRows}}</tbody></table>
|
||
</section>
|
||
</body>
|
||
</html>
|
||
""";
|
||
}
|
||
|
||
static async Task<List<ExportLog>> LoadRecentExportLogsAsync(IDbContextFactory<AppDbContext> dbFactory, DateTime startedAt)
|
||
{
|
||
await using var db = await dbFactory.CreateDbContextAsync();
|
||
return await db.ExportLogs
|
||
.AsNoTracking()
|
||
.Where(log => log.Timestamp >= startedAt.AddSeconds(-2))
|
||
.OrderByDescending(log => log.Id)
|
||
.Take(40)
|
||
.ToListAsync();
|
||
}
|
||
|
||
static string ResolveDatabasePath(string? configuredPath)
|
||
{
|
||
if (!string.IsNullOrWhiteSpace(configuredPath))
|
||
return Path.GetFullPath(configuredPath);
|
||
|
||
foreach (var start in new[] { Directory.GetCurrentDirectory(), AppContext.BaseDirectory })
|
||
{
|
||
var directory = new DirectoryInfo(start);
|
||
while (directory is not null)
|
||
{
|
||
var candidate = Path.Combine(directory.FullName, "trafag_exporter.db");
|
||
if (File.Exists(candidate))
|
||
return candidate;
|
||
|
||
directory = directory.Parent;
|
||
}
|
||
}
|
||
|
||
return Path.Combine(Directory.GetCurrentDirectory(), "trafag_exporter.db");
|
||
}
|
||
|
||
static string? ResolveCheckedExcelPath()
|
||
{
|
||
foreach (var start in new[] { Directory.GetCurrentDirectory(), AppContext.BaseDirectory })
|
||
{
|
||
var directory = new DirectoryInfo(start);
|
||
while (directory is not null)
|
||
{
|
||
var candidate = Path.Combine(directory.FullName, "check.xlsx");
|
||
if (File.Exists(candidate))
|
||
return candidate;
|
||
|
||
directory = directory.Parent;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static string? ResolveSpainSalesCsvPath()
|
||
{
|
||
foreach (var start in new[] { Directory.GetCurrentDirectory(), AppContext.BaseDirectory })
|
||
{
|
||
var directory = new DirectoryInfo(start);
|
||
while (directory is not null)
|
||
{
|
||
var directCandidate = Path.Combine(directory.FullName, "sagespain", "v2", "Spain_Sales_2025.csv");
|
||
if (File.Exists(directCandidate))
|
||
return directCandidate;
|
||
|
||
var recursiveCandidate = Directory
|
||
.EnumerateFiles(directory.FullName, "Spain_Sales_2025.csv", System.IO.SearchOption.AllDirectories)
|
||
.OrderByDescending(File.GetLastWriteTimeUtc)
|
||
.FirstOrDefault();
|
||
|
||
if (!string.IsNullOrWhiteSpace(recursiveCandidate))
|
||
return recursiveCandidate;
|
||
|
||
directory = directory.Parent;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static string? ResolveGermanySamplePath()
|
||
{
|
||
foreach (var start in new[] { Directory.GetCurrentDirectory(), AppContext.BaseDirectory })
|
||
{
|
||
var directory = new DirectoryInfo(start);
|
||
while (directory is not null)
|
||
{
|
||
var directCandidate = Path.Combine(directory.FullName, "DE_Beispiel_Export_Daten.xlsx");
|
||
if (File.Exists(directCandidate))
|
||
return directCandidate;
|
||
|
||
var recursiveCandidate = Directory
|
||
.EnumerateFiles(directory.FullName, "DE_Beispiel_Export_Daten.xlsx", System.IO.SearchOption.AllDirectories)
|
||
.OrderByDescending(File.GetLastWriteTimeUtc)
|
||
.FirstOrDefault();
|
||
|
||
if (!string.IsNullOrWhiteSpace(recursiveCandidate))
|
||
return recursiveCandidate;
|
||
|
||
directory = directory.Parent;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static Dictionary<string, CheckedExcelReference> LoadCheckedExcelReferences(string? path)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
|
||
return [];
|
||
|
||
using var workbook = new XLWorkbook(path);
|
||
var worksheet = workbook.Worksheets.First();
|
||
var references = new Dictionary<string, CheckedExcelReference>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
foreach (var row in worksheet.RowsUsed().Skip(1))
|
||
{
|
||
var label = row.Cell(1).GetString().Trim();
|
||
if (string.IsNullOrWhiteSpace(label) || label.Equals("Total TR Gruppe", StringComparison.OrdinalIgnoreCase))
|
||
continue;
|
||
|
||
references[label] = new CheckedExcelReference
|
||
{
|
||
Label = label,
|
||
LocalCurrencyValue = ReadNullableDecimal(row.Cell(2)),
|
||
ChfValue = ReadNullableDecimal(row.Cell(3)),
|
||
PowerBiValue = ReadNullableDecimal(row.Cell(5)),
|
||
Status = row.Cell(6).GetString().Trim()
|
||
};
|
||
}
|
||
|
||
return references;
|
||
}
|
||
|
||
static decimal? ReadNullableDecimal(IXLCell cell)
|
||
{
|
||
if (cell.IsEmpty())
|
||
return null;
|
||
|
||
return cell.TryGetValue<decimal>(out var value) ? value : null;
|
||
}
|
||
|
||
static GermanyExcelProbe? LoadGermanyExcelProbe(string? path)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
|
||
return null;
|
||
|
||
using var workbook = new XLWorkbook(path);
|
||
var worksheet = workbook.Worksheets.FirstOrDefault();
|
||
var usedRange = worksheet?.RangeUsed();
|
||
if (worksheet is null || usedRange is null)
|
||
return null;
|
||
|
||
var headerRow = usedRange.FirstRow();
|
||
var headers = headerRow.CellsUsed()
|
||
.ToDictionary(cell => cell.GetString().Trim(), cell => cell.Address.ColumnNumber, StringComparer.OrdinalIgnoreCase);
|
||
|
||
if (!headers.TryGetValue("NettoPreisGesamtX", out var amountColumn))
|
||
return null;
|
||
|
||
headers.TryGetValue("Währung", out var currencyColumn);
|
||
headers.TryGetValue("Belegdatum-Rechnung", out var invoiceDateColumn);
|
||
|
||
var total = 0m;
|
||
var rowsWithAmount = 0;
|
||
var rowsIn2025 = 0;
|
||
var totalIn2025 = 0m;
|
||
var currencies = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
foreach (var row in usedRange.RowsUsed().Skip(1))
|
||
{
|
||
var value = ReadProbeDecimal(row.Cell(amountColumn));
|
||
if (value == 0m)
|
||
continue;
|
||
|
||
total += value;
|
||
rowsWithAmount++;
|
||
|
||
if (currencyColumn > 0)
|
||
{
|
||
var currency = row.Cell(currencyColumn).GetString().Trim();
|
||
if (!string.IsNullOrWhiteSpace(currency))
|
||
currencies.Add(currency);
|
||
}
|
||
|
||
if (invoiceDateColumn > 0 && TryReadProbeDate(row.Cell(invoiceDateColumn), out var invoiceDate) && invoiceDate.Year == 2025)
|
||
{
|
||
totalIn2025 += value;
|
||
rowsIn2025++;
|
||
}
|
||
}
|
||
|
||
return new GermanyExcelProbe
|
||
{
|
||
Path = path,
|
||
RowsWithAmount = rowsWithAmount,
|
||
SalesPriceValue = total,
|
||
RowsIn2025 = rowsIn2025,
|
||
SalesPriceValueIn2025 = totalIn2025,
|
||
Currencies = string.Join(", ", currencies.OrderBy(x => x, StringComparer.OrdinalIgnoreCase))
|
||
};
|
||
}
|
||
|
||
static async Task<List<SiteCoverageRow>> LoadSiteCoverageAsync(IDbContextFactory<AppDbContext> dbFactory, int year)
|
||
{
|
||
await using var db = await dbFactory.CreateDbContextAsync();
|
||
var sites = await db.Sites
|
||
.AsNoTracking()
|
||
.OrderBy(s => s.Land)
|
||
.ThenBy(s => s.TSC)
|
||
.Select(s => new
|
||
{
|
||
s.Id,
|
||
s.Land,
|
||
s.TSC,
|
||
s.SourceSystem,
|
||
s.ManualImportFilePath,
|
||
s.IsActive
|
||
})
|
||
.ToListAsync();
|
||
var sourceSystems = await db.SourceSystemDefinitions
|
||
.AsNoTracking()
|
||
.ToDictionaryAsync(s => s.Code, StringComparer.OrdinalIgnoreCase);
|
||
var centralBaseRows = await db.CentralSalesRecords
|
||
.AsNoTracking()
|
||
.Where(r => (r.PostingDate ?? r.InvoiceDate ?? r.ExtractionDate).Year == year)
|
||
.Select(r => new
|
||
{
|
||
r.SiteId,
|
||
r.SalesPriceValue,
|
||
Date = r.PostingDate ?? r.InvoiceDate ?? r.ExtractionDate,
|
||
Currency = string.IsNullOrWhiteSpace(r.CompanyCurrency) ? r.SalesCurrency : r.CompanyCurrency
|
||
})
|
||
.ToListAsync();
|
||
var centralRows = centralBaseRows
|
||
.GroupBy(r => r.SiteId)
|
||
.ToDictionary(g => g.Key, g => new
|
||
{
|
||
Rows = g.Count(),
|
||
Sales = g.Sum(r => r.SalesPriceValue),
|
||
MinDate = g.Min(r => r.Date),
|
||
MaxDate = g.Max(r => r.Date),
|
||
Currencies = g.Select(r => r.Currency).Distinct(StringComparer.OrdinalIgnoreCase).ToList()
|
||
});
|
||
var latestLogs = await db.ExportLogs
|
||
.AsNoTracking()
|
||
.GroupBy(l => l.SiteId)
|
||
.Select(g => g.OrderByDescending(l => l.Id).First())
|
||
.ToDictionaryAsync(l => l.SiteId);
|
||
|
||
return sites.Select(site =>
|
||
{
|
||
sourceSystems.TryGetValue(site.SourceSystem, out var sourceSystem);
|
||
centralRows.TryGetValue(site.Id, out var central);
|
||
latestLogs.TryGetValue(site.Id, out var latestLog);
|
||
return new SiteCoverageRow
|
||
{
|
||
Land = site.Land,
|
||
Tsc = site.TSC,
|
||
SourceSystem = site.SourceSystem,
|
||
SourceDisplayName = sourceSystem?.DisplayName ?? site.SourceSystem,
|
||
ConnectionKind = sourceSystem?.ConnectionKind ?? string.Empty,
|
||
IsActive = site.IsActive,
|
||
ManualImportPath = site.ManualImportFilePath,
|
||
RowCount = central?.Rows ?? 0,
|
||
SalesPriceValue = central?.Sales,
|
||
MinDate = central?.MinDate,
|
||
MaxDate = central?.MaxDate,
|
||
Currencies = central is null ? string.Empty : string.Join(", ", central.Currencies.Where(x => !string.IsNullOrWhiteSpace(x)).OrderBy(x => x, StringComparer.OrdinalIgnoreCase)),
|
||
LastExportStatus = latestLog?.Status ?? string.Empty,
|
||
LastExportAt = latestLog?.Timestamp,
|
||
LastExportError = latestLog?.ErrorMessage ?? string.Empty
|
||
};
|
||
}).ToList();
|
||
}
|
||
|
||
static decimal ReadProbeDecimal(IXLCell cell)
|
||
{
|
||
if (cell.TryGetValue<decimal>(out var decimalValue))
|
||
return decimalValue;
|
||
|
||
var text = cell.GetString().Trim();
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
return 0m;
|
||
|
||
text = text
|
||
.Replace("'", string.Empty)
|
||
.Replace("’", string.Empty)
|
||
.Replace(" ", string.Empty)
|
||
.Replace(",", ".");
|
||
|
||
return decimal.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out var parsed)
|
||
? parsed
|
||
: 0m;
|
||
}
|
||
|
||
static bool TryReadProbeDate(IXLCell cell, out DateTime value)
|
||
{
|
||
if (cell.TryGetValue<DateTime>(out value))
|
||
return true;
|
||
|
||
return DateTime.TryParse(cell.GetString(), CultureInfo.GetCultureInfo("de-CH"), DateTimeStyles.None, out value) ||
|
||
DateTime.TryParse(cell.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.None, out value);
|
||
}
|
||
|
||
static SpainSalesCsvProbe? LoadSpainSalesCsvProbe(string? path)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
|
||
return null;
|
||
|
||
using var parser = new TextFieldParser(path)
|
||
{
|
||
TextFieldType = FieldType.Delimited,
|
||
HasFieldsEnclosedInQuotes = true,
|
||
TrimWhiteSpace = false
|
||
};
|
||
parser.SetDelimiters(";");
|
||
|
||
var header = parser.ReadFields();
|
||
if (header is null)
|
||
return null;
|
||
|
||
var headerMap = header
|
||
.Select((name, index) => new { Name = name.Trim(), Index = index })
|
||
.ToDictionary(x => x.Name, x => x.Index, StringComparer.OrdinalIgnoreCase);
|
||
|
||
if (!headerMap.TryGetValue("SalesPriceValue", out var salesIndex))
|
||
return null;
|
||
|
||
headerMap.TryGetValue("DocumentType", out var documentTypeIndex);
|
||
headerMap.TryGetValue("InvoiceSeries", out var invoiceSeriesIndex);
|
||
|
||
var rows = 0;
|
||
var total = 0m;
|
||
var byDocumentType = new Dictionary<string, (int Rows, decimal Sales)>(StringComparer.OrdinalIgnoreCase);
|
||
var bySeries = new Dictionary<string, (int Rows, decimal Sales)>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
while (!parser.EndOfData)
|
||
{
|
||
var fields = parser.ReadFields();
|
||
if (fields is null || fields.All(string.IsNullOrWhiteSpace))
|
||
continue;
|
||
|
||
var sales = salesIndex < fields.Length ? ParseProbeDecimal(fields[salesIndex]) : 0m;
|
||
var documentType = documentTypeIndex < fields.Length && !string.IsNullOrWhiteSpace(fields[documentTypeIndex])
|
||
? fields[documentTypeIndex]
|
||
: "-";
|
||
var series = invoiceSeriesIndex < fields.Length && !string.IsNullOrWhiteSpace(fields[invoiceSeriesIndex])
|
||
? fields[invoiceSeriesIndex]
|
||
: "-";
|
||
|
||
rows++;
|
||
total += sales;
|
||
AddGroupValue(byDocumentType, documentType, sales);
|
||
AddGroupValue(bySeries, series, sales);
|
||
}
|
||
|
||
const decimal reference = 3102333.61m;
|
||
return new SpainSalesCsvProbe
|
||
{
|
||
Path = path,
|
||
Rows = rows,
|
||
SalesPriceValue = total,
|
||
ReferenceValue = reference,
|
||
Difference = total - reference,
|
||
ByDocumentType = byDocumentType
|
||
.OrderBy(x => x.Key, StringComparer.OrdinalIgnoreCase)
|
||
.Select(x => new SpainSalesCsvGroup(x.Key, x.Value.Rows, x.Value.Sales))
|
||
.ToList(),
|
||
BySeries = bySeries
|
||
.OrderBy(x => x.Key, StringComparer.OrdinalIgnoreCase)
|
||
.Select(x => new SpainSalesCsvGroup(x.Key, x.Value.Rows, x.Value.Sales))
|
||
.ToList()
|
||
};
|
||
}
|
||
|
||
static void AddGroupValue(Dictionary<string, (int Rows, decimal Sales)> groups, string key, decimal sales)
|
||
{
|
||
groups.TryGetValue(key, out var current);
|
||
groups[key] = (current.Rows + 1, current.Sales + sales);
|
||
}
|
||
|
||
static decimal ParseProbeDecimal(string text)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
return 0m;
|
||
|
||
return decimal.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out var value)
|
||
? value
|
||
: 0m;
|
||
}
|
||
|
||
static string BuildPage(
|
||
IReadOnlyList<NetSalesReferenceRow> rows,
|
||
string databasePath,
|
||
IReadOnlyDictionary<string, CheckedExcelReference> excelReferences,
|
||
SpainSalesCsvProbe? spainCsv,
|
||
GermanyExcelProbe? germanySample,
|
||
IReadOnlyList<SiteCoverageRow> coverage)
|
||
{
|
||
var generatedAt = DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss", CultureInfo.GetCultureInfo("de-CH"));
|
||
var okCount = rows.Count(r => r.Status == "OK");
|
||
var checkCount = rows.Count(r => r.Status == "Pruefen");
|
||
var missingCount = rows.Count(r => r.Status == "Keine Daten");
|
||
var excelCount = excelReferences.Count;
|
||
var financeChiefOverview = BuildFinanceChiefOverview(rows, excelReferences, spainCsv, germanySample);
|
||
var executiveBriefing = BuildExecutiveBriefing(rows, excelReferences, spainCsv, germanySample);
|
||
var detailRows = BuildDetailRows(rows, excelReferences, spainCsv);
|
||
var coverageRows = BuildCoverageRows(coverage);
|
||
var spainCsvSection = BuildSpainCsvSection(spainCsv);
|
||
var germanySampleSection = BuildGermanySampleSection(germanySample, excelReferences);
|
||
|
||
return $$"""
|
||
<!doctype html>
|
||
<html lang="de">
|
||
<head>
|
||
<meta charset="utf-8">
|
||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||
<title>Finance Probe</title>
|
||
<style>
|
||
:root {
|
||
color-scheme: light;
|
||
--bg: #f6f7f9;
|
||
--panel: #ffffff;
|
||
--text: #17202a;
|
||
--muted: #667085;
|
||
--line: #d8dee8;
|
||
--ok: #147a3d;
|
||
--check: #a15c00;
|
||
--missing: #667085;
|
||
--head: #22324a;
|
||
}
|
||
* { box-sizing: border-box; }
|
||
body {
|
||
margin: 0;
|
||
background: var(--bg);
|
||
color: var(--text);
|
||
font-family: "Segoe UI", Arial, sans-serif;
|
||
font-size: 14px;
|
||
}
|
||
header {
|
||
padding: 18px 24px 12px;
|
||
background: var(--panel);
|
||
border-bottom: 1px solid var(--line);
|
||
}
|
||
h1 {
|
||
margin: 0 0 8px;
|
||
font-size: 22px;
|
||
font-weight: 650;
|
||
letter-spacing: 0;
|
||
}
|
||
.meta {
|
||
color: var(--muted);
|
||
display: flex;
|
||
flex-wrap: wrap;
|
||
gap: 12px;
|
||
line-height: 1.5;
|
||
}
|
||
nav {
|
||
display: flex;
|
||
flex-wrap: wrap;
|
||
gap: 8px;
|
||
margin-top: 12px;
|
||
}
|
||
nav a {
|
||
color: #1f4f7a;
|
||
text-decoration: none;
|
||
border: 1px solid var(--line);
|
||
border-radius: 6px;
|
||
padding: 6px 10px;
|
||
background: #f8fafc;
|
||
font-weight: 600;
|
||
}
|
||
main { padding: 18px 24px 28px; }
|
||
.summary {
|
||
display: grid;
|
||
grid-template-columns: repeat(4, minmax(140px, 1fr));
|
||
gap: 10px;
|
||
margin-bottom: 14px;
|
||
}
|
||
.metric {
|
||
background: var(--panel);
|
||
border: 1px solid var(--line);
|
||
border-radius: 6px;
|
||
padding: 10px 12px;
|
||
}
|
||
.metric strong {
|
||
display: block;
|
||
font-size: 20px;
|
||
margin-bottom: 2px;
|
||
}
|
||
.metric span { color: var(--muted); }
|
||
table {
|
||
width: 100%;
|
||
border-collapse: collapse;
|
||
background: var(--panel);
|
||
border: 1px solid var(--line);
|
||
}
|
||
th {
|
||
text-align: left;
|
||
background: var(--head);
|
||
color: #fff;
|
||
font-weight: 600;
|
||
padding: 8px 10px;
|
||
position: sticky;
|
||
top: 0;
|
||
z-index: 1;
|
||
}
|
||
td {
|
||
padding: 7px 10px;
|
||
border-top: 1px solid var(--line);
|
||
vertical-align: top;
|
||
}
|
||
tbody tr:nth-child(even) { background: #fafbfc; }
|
||
.num {
|
||
text-align: right;
|
||
font-variant-numeric: tabular-nums;
|
||
white-space: nowrap;
|
||
}
|
||
.status {
|
||
display: inline-block;
|
||
min-width: 78px;
|
||
padding: 3px 8px;
|
||
border-radius: 999px;
|
||
color: #fff;
|
||
text-align: center;
|
||
font-size: 12px;
|
||
font-weight: 650;
|
||
}
|
||
.OK { background: var(--ok); }
|
||
.Pruefen { background: var(--check); }
|
||
.KeineDaten { background: var(--missing); }
|
||
details { min-width: 360px; }
|
||
summary { cursor: pointer; color: #234d7d; }
|
||
.candidate-table {
|
||
margin-top: 8px;
|
||
border: 1px solid var(--line);
|
||
font-size: 13px;
|
||
}
|
||
.candidate-table th {
|
||
background: #eef2f7;
|
||
color: var(--text);
|
||
position: static;
|
||
}
|
||
.small { color: var(--muted); font-size: 12px; }
|
||
.briefing {
|
||
background: var(--panel);
|
||
border: 1px solid var(--line);
|
||
border-radius: 6px;
|
||
padding: 12px;
|
||
margin-bottom: 14px;
|
||
}
|
||
.briefing h2 {
|
||
margin: 0 0 6px;
|
||
font-size: 18px;
|
||
letter-spacing: 0;
|
||
}
|
||
.briefing-note {
|
||
color: var(--muted);
|
||
margin: 0 0 10px;
|
||
line-height: 1.45;
|
||
}
|
||
.chief-note {
|
||
color: var(--muted);
|
||
margin: 0;
|
||
line-height: 1.45;
|
||
}
|
||
.chief-summary {
|
||
display: grid;
|
||
grid-template-columns: repeat(3, minmax(120px, 1fr));
|
||
gap: 10px;
|
||
margin: 10px 0;
|
||
}
|
||
.chief-summary .metric {
|
||
margin: 0;
|
||
}
|
||
.chief-action {
|
||
min-width: 240px;
|
||
max-width: 380px;
|
||
line-height: 1.35;
|
||
}
|
||
.ampel {
|
||
display: inline-flex;
|
||
align-items: center;
|
||
gap: 7px;
|
||
white-space: nowrap;
|
||
font-weight: 650;
|
||
}
|
||
.ampel::before {
|
||
content: "";
|
||
width: 12px;
|
||
height: 12px;
|
||
border-radius: 999px;
|
||
display: inline-block;
|
||
box-shadow: 0 0 0 2px rgba(0, 0, 0, 0.06);
|
||
}
|
||
.ampel-ok::before { background: #168a48; }
|
||
.ampel-check::before { background: #e6a100; }
|
||
.ampel-missing::before { background: #9aa4b2; }
|
||
.wrap {
|
||
min-width: 240px;
|
||
max-width: 420px;
|
||
line-height: 1.35;
|
||
}
|
||
@media (max-width: 900px) {
|
||
main, header { padding-left: 12px; padding-right: 12px; }
|
||
.summary { grid-template-columns: repeat(2, minmax(120px, 1fr)); }
|
||
.table-wrap { overflow-x: auto; }
|
||
}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<header>
|
||
<h1>Finance Probe - Net Sales Actuals 2025</h1>
|
||
<div class="meta">
|
||
<span>Vergleich gegen gepruefte Sollwerte aus check.xlsx Stand 29.04.2026</span>
|
||
<span>DB: {{Html(databasePath)}}</span>
|
||
<span>Excel-Referenzen gelesen: {{excelCount}}</span>
|
||
<span>Aktualisiert: {{Html(generatedAt)}}</span>
|
||
</div>
|
||
<nav aria-label="Finance Probe Navigation">
|
||
<a href="#chef">Finanzchef Übersicht</a>
|
||
<a href="#briefing">Meeting Ampel</a>
|
||
<a href="#all-sites">Detail alle Laender</a>
|
||
<a href="#coverage">Datenabdeckung</a>
|
||
<a href="#germany-sample">Germany Excel</a>
|
||
<a href="#spain-csv">Spain CSV</a>
|
||
</nav>
|
||
</header>
|
||
<main>
|
||
{{financeChiefOverview}}
|
||
{{executiveBriefing}}
|
||
<section class="summary">
|
||
<div class="metric"><strong>{{rows.Count}}</strong><span>Standorte</span></div>
|
||
<div class="metric"><strong>{{okCount}}</strong><span>OK</span></div>
|
||
<div class="metric"><strong>{{checkCount}}</strong><span>Pruefen</span></div>
|
||
<div class="metric"><strong>{{missingCount}}</strong><span>Keine Daten</span></div>
|
||
<div class="metric"><strong>{{coverage.Count}}</strong><span>Konfigurierte Standorte</span></div>
|
||
</section>
|
||
<div id="all-sites" class="table-wrap">
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>Status</th>
|
||
<th>Firma</th>
|
||
<th>Gewaehlte Abgrenzung</th>
|
||
<th>Ist-Waehrung</th>
|
||
<th class="num">Ist 2025</th>
|
||
<th>Referenz-Waehrung</th>
|
||
<th class="num">Referenz</th>
|
||
<th class="num">Excel LC</th>
|
||
<th class="num">Excel CHF</th>
|
||
<th class="num">Excel Sollwert</th>
|
||
<th>Excel Status</th>
|
||
<th class="num">Differenz</th>
|
||
<th class="num">Ohne 2nd-party Diff.</th>
|
||
<th>Waehrung</th>
|
||
<th class="num">Zeilen</th>
|
||
<th>Varianten</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{{detailRows}}
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
{{coverageRows}}
|
||
{{germanySampleSection}}
|
||
{{spainCsvSection}}
|
||
</main>
|
||
</body>
|
||
</html>
|
||
""";
|
||
}
|
||
|
||
static string BuildCoverageRows(IReadOnlyList<SiteCoverageRow> coverage)
|
||
{
|
||
if (coverage.Count == 0)
|
||
return string.Empty;
|
||
|
||
var rows = string.Join(Environment.NewLine, coverage.Select(row =>
|
||
{
|
||
var sourceDetail = row.ConnectionKind switch
|
||
{
|
||
"MANUAL_EXCEL" when !string.IsNullOrWhiteSpace(row.ManualImportPath) => row.ManualImportPath,
|
||
"MANUAL_EXCEL" => "Kein Manual-Dateipfad hinterlegt",
|
||
_ => row.SourceDisplayName
|
||
};
|
||
var period = row.RowCount == 0
|
||
? "-"
|
||
: $"{row.MinDate:dd.MM.yyyy} - {row.MaxDate:dd.MM.yyyy}";
|
||
var lastExport = row.LastExportAt.HasValue
|
||
? $"{row.LastExportAt:dd.MM.yyyy HH:mm} / {row.LastExportStatus}"
|
||
: "-";
|
||
var issue = BuildCoverageIssue(row);
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><strong>{{Html(row.Land)}}</strong><div class="small">{{Html(row.Tsc)}}</div></td>
|
||
<td>{{Html(row.SourceSystem)}}<div class="small">{{Html(row.ConnectionKind)}}</div></td>
|
||
<td class="wrap">{{Html(sourceDetail)}}</td>
|
||
<td>{{(row.IsActive ? "Ja" : "Nein")}}</td>
|
||
<td class="num">{{row.RowCount}}</td>
|
||
<td class="num">{{Amount(row.SalesPriceValue)}}</td>
|
||
<td>{{Html(row.Currencies)}}</td>
|
||
<td>{{Html(period)}}</td>
|
||
<td>{{Html(lastExport)}}</td>
|
||
<td class="wrap">{{Html(issue)}}</td>
|
||
</tr>
|
||
""";
|
||
}));
|
||
|
||
return $$"""
|
||
<section id="coverage" style="margin-top:18px;">
|
||
<h2 style="font-size:18px;margin:0 0 8px;">Datenabdeckung je Standort</h2>
|
||
<p class="briefing-note">Diese Tabelle zeigt, welche Standorte in der App konfiguriert sind, welche Quelle sie nutzen und ob fuer 2025 bereits Daten in `CentralSalesRecords` liegen.</p>
|
||
<div class="table-wrap">
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>Standort</th>
|
||
<th>System</th>
|
||
<th>Quelle / Pfad</th>
|
||
<th>Aktiv</th>
|
||
<th class="num">Zeilen 2025</th>
|
||
<th class="num">SalesPriceValue</th>
|
||
<th>Waehrung</th>
|
||
<th>Periode</th>
|
||
<th>Letzter Export</th>
|
||
<th>Hinweis</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>{{rows}}</tbody>
|
||
</table>
|
||
</div>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
static string BuildCoverageIssue(SiteCoverageRow row)
|
||
{
|
||
if (!row.IsActive)
|
||
return "Standort ist deaktiviert.";
|
||
if (row.ConnectionKind == "MANUAL_EXCEL" && string.IsNullOrWhiteSpace(row.ManualImportPath))
|
||
return "Manual Excel/CSV-Pfad fehlt.";
|
||
if (!string.IsNullOrWhiteSpace(row.LastExportError))
|
||
return row.LastExportError;
|
||
if (row.RowCount == 0)
|
||
return "Keine 2025-Daten in CentralSalesRecords. Export pruefen.";
|
||
if (!string.IsNullOrWhiteSpace(row.LastExportStatus) && !row.LastExportStatus.Equals("OK", StringComparison.OrdinalIgnoreCase))
|
||
return $"Letzter Exportstatus: {row.LastExportStatus}.";
|
||
return "Daten vorhanden.";
|
||
}
|
||
|
||
static string BuildDetailRows(
|
||
IReadOnlyList<NetSalesReferenceRow> rows,
|
||
IReadOnlyDictionary<string, CheckedExcelReference> excelReferences,
|
||
SpainSalesCsvProbe? spainCsv)
|
||
{
|
||
var detailRows = rows
|
||
.Where(row => spainCsv is null || !row.Key.Equals("ES", StringComparison.OrdinalIgnoreCase))
|
||
.Select(row => (Label: row.Label, Html: BuildRow(row, excelReferences)))
|
||
.ToList();
|
||
|
||
if (spainCsv is not null)
|
||
{
|
||
excelReferences.TryGetValue("Trafag ES", out var excelReference);
|
||
detailRows.Add(("Trafag ES", BuildSpainDetailRow(spainCsv, excelReference)));
|
||
}
|
||
|
||
return string.Join(
|
||
Environment.NewLine,
|
||
detailRows
|
||
.OrderBy(row => row.Label, StringComparer.OrdinalIgnoreCase)
|
||
.Select(row => row.Html));
|
||
}
|
||
|
||
static string BuildFinanceChiefOverview(
|
||
IReadOnlyList<NetSalesReferenceRow> rows,
|
||
IReadOnlyDictionary<string, CheckedExcelReference> excelReferences,
|
||
SpainSalesCsvProbe? spainCsv,
|
||
GermanyExcelProbe? germanySample)
|
||
{
|
||
var issues = BuildFinanceChiefIssues(rows, excelReferences, spainCsv, germanySample).ToList();
|
||
var openIssues = issues
|
||
.Where(issue => issue.Status != "OK")
|
||
.OrderByDescending(issue => issue.SortValue)
|
||
.ThenBy(issue => issue.Label, StringComparer.OrdinalIgnoreCase)
|
||
.ToList();
|
||
|
||
var missingCount = openIssues.Count(issue => issue.Status == "Keine Daten");
|
||
var checkCount = openIssues.Count(issue => issue.Status == "Pruefen");
|
||
var largestDifference = openIssues
|
||
.Where(issue => issue.Difference.HasValue)
|
||
.Select(issue => Math.Abs(issue.Difference!.Value))
|
||
.DefaultIfEmpty(0m)
|
||
.Max();
|
||
var tableRows = openIssues.Count == 0
|
||
? """
|
||
<tr>
|
||
<td colspan="7" class="wrap">Keine offenen Abweichungen. Alle vorhandenen Laender passen rechnerisch gegen den Sollwert.</td>
|
||
</tr>
|
||
"""
|
||
: string.Join(Environment.NewLine, openIssues.Select(BuildFinanceChiefIssueRow));
|
||
|
||
return $$"""
|
||
<section id="chef" class="briefing">
|
||
<h2>Finanzchef Übersicht</h2>
|
||
<p class="chief-note">Kompakte Sicht nur auf offene Soll/Ist-Themen. Detailtabellen bleiben unten fuer Analyse und Nachvollzug.</p>
|
||
<div class="chief-summary">
|
||
<div class="metric"><strong>{{openIssues.Count}}</strong><span>Offen</span></div>
|
||
<div class="metric"><strong>{{checkCount}}</strong><span>Abweichungen</span></div>
|
||
<div class="metric"><strong>{{missingCount}}</strong><span>Keine Daten</span></div>
|
||
</div>
|
||
<div class="chief-note" style="margin-bottom:10px;">Groesste absolute Abweichung: {{Amount(largestDifference)}}</div>
|
||
<div class="table-wrap">
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>Status</th>
|
||
<th>Land</th>
|
||
<th>Waehrung</th>
|
||
<th class="num">Ist</th>
|
||
<th class="num">Soll</th>
|
||
<th class="num">Abweichung</th>
|
||
<th>Was ist zu pruefen</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>{{tableRows}}</tbody>
|
||
</table>
|
||
</div>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
static IEnumerable<FinanceChiefIssue> BuildFinanceChiefIssues(
|
||
IReadOnlyList<NetSalesReferenceRow> rows,
|
||
IReadOnlyDictionary<string, CheckedExcelReference> excelReferences,
|
||
SpainSalesCsvProbe? spainCsv,
|
||
GermanyExcelProbe? germanySample)
|
||
{
|
||
var issues = rows
|
||
.Where(row => spainCsv is null || !row.Key.Equals("ES", StringComparison.OrdinalIgnoreCase))
|
||
.Select(row => new FinanceChiefIssue(
|
||
row.Status,
|
||
row.Label,
|
||
row.Key,
|
||
BuildFinanceChiefCurrency(row),
|
||
row.ActualValue,
|
||
row.ReferenceValue,
|
||
row.Difference,
|
||
BuildFinanceChiefReason(row, germanySample),
|
||
row.Difference.HasValue ? Math.Abs(row.Difference.Value) : decimal.MaxValue))
|
||
.ToList();
|
||
|
||
if (spainCsv is not null)
|
||
{
|
||
var status = Math.Abs(spainCsv.Difference) <= 1m ? "OK" : "Pruefen";
|
||
issues.Add(new FinanceChiefIssue(
|
||
status,
|
||
"Trafag ES",
|
||
"ES",
|
||
"EUR",
|
||
spainCsv.SalesPriceValue,
|
||
spainCsv.ReferenceValue,
|
||
spainCsv.Difference,
|
||
status == "OK"
|
||
? "Spain CSV passt rechnerisch gegen check.xlsx."
|
||
: "Spain CSV hat Differenz. Periodenabgrenzung, Serien REG/LAT/PRO/REC und Gutschriften pruefen.",
|
||
Math.Abs(spainCsv.Difference)));
|
||
}
|
||
|
||
var existingLabels = issues
|
||
.Select(issue => issue.Label)
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
foreach (var reference in excelReferences.Values)
|
||
{
|
||
if (existingLabels.Contains(reference.Label))
|
||
continue;
|
||
|
||
var referenceValue = reference.PowerBiValue ?? reference.LocalCurrencyValue;
|
||
issues.Add(new FinanceChiefIssue(
|
||
"Keine Daten",
|
||
reference.Label,
|
||
"check.xlsx",
|
||
reference.PowerBiValue.HasValue ? "Sollwert" : "LC",
|
||
null,
|
||
referenceValue,
|
||
null,
|
||
"Sollwert ist in check.xlsx vorhanden, aber es gibt keinen belastbaren Ist-Import. Standort, Export oder Aktivierung pruefen.",
|
||
decimal.MaxValue));
|
||
}
|
||
|
||
return issues;
|
||
}
|
||
|
||
static string BuildFinanceChiefIssueRow(FinanceChiefIssue issue)
|
||
{
|
||
var statusClass = issue.Status.Replace(" ", string.Empty);
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><span class="status {{Html(statusClass)}}">{{Html(issue.Status)}}</span></td>
|
||
<td><strong>{{Html(issue.Label)}}</strong><div class="small">{{Html(issue.Key)}}</div></td>
|
||
<td>{{Html(issue.Currency)}}</td>
|
||
<td class="num">{{Amount(issue.ActualValue)}}</td>
|
||
<td class="num">{{Amount(issue.ReferenceValue)}}</td>
|
||
<td class="num">{{Amount(issue.Difference)}}</td>
|
||
<td class="chief-action">{{Html(issue.Reason)}}</td>
|
||
</tr>
|
||
""";
|
||
}
|
||
|
||
static string BuildFinanceChiefCurrency(NetSalesReferenceRow row)
|
||
{
|
||
var actualCurrency = string.IsNullOrWhiteSpace(row.ActualCurrency) ? row.Currencies : row.ActualCurrency;
|
||
var referenceCurrency = row.ReferenceCurrency;
|
||
|
||
if (string.IsNullOrWhiteSpace(actualCurrency) && string.IsNullOrWhiteSpace(referenceCurrency))
|
||
return "-";
|
||
if (string.IsNullOrWhiteSpace(referenceCurrency) ||
|
||
referenceCurrency.Equals("Sollwert", StringComparison.OrdinalIgnoreCase) ||
|
||
actualCurrency.Equals(referenceCurrency, StringComparison.OrdinalIgnoreCase))
|
||
return actualCurrency;
|
||
if (string.IsNullOrWhiteSpace(actualCurrency))
|
||
return referenceCurrency;
|
||
|
||
return $"{actualCurrency} / Soll {referenceCurrency}";
|
||
}
|
||
|
||
static string BuildFinanceChiefReason(NetSalesReferenceRow row, GermanyExcelProbe? germanySample)
|
||
{
|
||
if (row.Key.Equals("DE", StringComparison.OrdinalIgnoreCase) && germanySample is not null)
|
||
return "DE-Beispielfile ist lesbar, aber nur Sample. Finalen Jahresexport/Abgrenzung pruefen.";
|
||
|
||
if (row.Status == "OK")
|
||
return "Passt rechnerisch gegen check.xlsx.";
|
||
|
||
if (row.Status == "Keine Daten")
|
||
return "Kein belastbarer Ist-Import. Standort, Export, Mapping oder Aktivierung pruefen.";
|
||
|
||
if (row.DifferenceExcludingIntercompany.HasValue &&
|
||
Math.Abs(row.DifferenceExcludingIntercompany.Value) <= 1m)
|
||
return "Abweichung ist nach 2nd-party/Intercompany-Abzug erklaerbar. IC-Regel fachlich bestaetigen.";
|
||
|
||
if (row.Candidates.Count > 1)
|
||
return "Abweichung offen. Gewaehlter Wert folgt Hauswaehrung/Nettofakturawert; alternative Summen sind in Details sichtbar.";
|
||
|
||
return "Abweichung offen. Quelle, Periodenabgrenzung, Gutschriften und 2nd-party/3rd-party-Abgrenzung pruefen.";
|
||
}
|
||
|
||
static string BuildExecutiveBriefing(
|
||
IReadOnlyList<NetSalesReferenceRow> rows,
|
||
IReadOnlyDictionary<string, CheckedExcelReference> excelReferences,
|
||
SpainSalesCsvProbe? spainCsv,
|
||
GermanyExcelProbe? germanySample)
|
||
{
|
||
var briefingRows = rows
|
||
.Where(row => spainCsv is null || !row.Key.Equals("ES", StringComparison.OrdinalIgnoreCase))
|
||
.Select(row => (Label: row.Label, Html: BuildExecutiveRow(row, germanySample)))
|
||
.ToList();
|
||
|
||
if (spainCsv is not null)
|
||
briefingRows.Add(("Trafag ES", BuildSpainExecutiveRow(spainCsv)));
|
||
|
||
var existingLabels = briefingRows
|
||
.Select(row => row.Label)
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
foreach (var reference in excelReferences.Values)
|
||
{
|
||
if (existingLabels.Contains(reference.Label))
|
||
continue;
|
||
|
||
briefingRows.Add((reference.Label, BuildMissingExecutiveRow(reference)));
|
||
}
|
||
|
||
var tableRows = string.Join(
|
||
Environment.NewLine,
|
||
briefingRows
|
||
.OrderBy(row => row.Label, StringComparer.OrdinalIgnoreCase)
|
||
.Select(row => row.Html));
|
||
|
||
return $$"""
|
||
<section id="briefing" class="briefing">
|
||
<h2>Meeting Ampel 2025</h2>
|
||
<p class="briefing-note">Gruen = Zahl passt rechnerisch. Gelb = Differenz oder fachliche Abgrenzung offen. Grau = keine belastbaren Importdaten. Fachliche Regel: Net Sales Actuals werden in Hauswaehrung aus dem Nettofakturawert abgegrenzt; CHF-Ausweis nutzt Budgetkurse 2025 und wird pro Belegposition gerechnet, sobald die Positionswerte in Hauswaehrung verfuegbar sind.</p>
|
||
<div class="table-wrap">
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>Ampel</th>
|
||
<th>Land</th>
|
||
<th class="num">Ist</th>
|
||
<th class="num">Soll</th>
|
||
<th class="num">Differenz</th>
|
||
<th>Passender Wert</th>
|
||
<th>Waehrung / CHF</th>
|
||
<th>Warum / offen</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>{{tableRows}}</tbody>
|
||
</table>
|
||
</div>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
static string BuildMissingExecutiveRow(CheckedExcelReference reference)
|
||
{
|
||
var referenceValue = reference.PowerBiValue ?? reference.LocalCurrencyValue;
|
||
var source = reference.PowerBiValue.HasValue ? "Sollwert" : "LC";
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><span class="ampel ampel-missing">Grau</span></td>
|
||
<td><strong>{{Html(reference.Label)}}</strong><div class="small">check.xlsx</div></td>
|
||
<td class="num">-</td>
|
||
<td class="num">{{Amount(referenceValue)}}</td>
|
||
<td class="num">-</td>
|
||
<td>Kein Ist-Import (check.xlsx {{Html(source)}})</td>
|
||
<td class="wrap">Waehrung aus Quelle noch nicht belegbar. CHF nur wenn check.xlsx-Spalte CHF verwendet wird.</td>
|
||
<td class="wrap">In check.xlsx vorhanden, aber im aktuellen Import/aktiven Standort nicht belastbar. Export oder Standortaktivierung pruefen.</td>
|
||
</tr>
|
||
""";
|
||
}
|
||
|
||
static string BuildExecutiveRow(NetSalesReferenceRow row, GermanyExcelProbe? germanySample)
|
||
{
|
||
var ampelClass = row.Status switch
|
||
{
|
||
"OK" => "ampel-ok",
|
||
"Pruefen" => "ampel-check",
|
||
_ => "ampel-missing"
|
||
};
|
||
var ampelText = row.Status switch
|
||
{
|
||
"OK" => "Gruen",
|
||
"Pruefen" => "Gelb",
|
||
_ => "Grau"
|
||
};
|
||
var matchingValue = string.IsNullOrWhiteSpace(row.ValueField)
|
||
? "Noch kein Wert gewaehlt"
|
||
: $"{row.ValueField} ({row.ReferenceSource})";
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><span class="ampel {{ampelClass}}">{{ampelText}}</span></td>
|
||
<td><strong>{{Html(row.Label)}}</strong><div class="small">{{Html(row.Key)}}</div></td>
|
||
<td class="num">{{Amount(row.ActualValue)}}</td>
|
||
<td class="num">{{Amount(row.ReferenceValue)}}</td>
|
||
<td class="num">{{Amount(row.Difference)}}</td>
|
||
<td>{{Html(matchingValue)}}</td>
|
||
<td class="wrap">{{Html(BuildCurrencyNote(row))}}</td>
|
||
<td class="wrap">{{Html(BuildExecutiveReason(row, germanySample))}}</td>
|
||
</tr>
|
||
""";
|
||
}
|
||
|
||
static string BuildSpainExecutiveRow(SpainSalesCsvProbe spainCsv)
|
||
{
|
||
var ampelClass = Math.Abs(spainCsv.Difference) <= 1m ? "ampel-ok" : "ampel-check";
|
||
var ampelText = Math.Abs(spainCsv.Difference) <= 1m ? "Gruen" : "Gelb";
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><span class="ampel {{ampelClass}}">{{ampelText}}</span></td>
|
||
<td><strong>Trafag ES</strong><div class="small">ES / Sage Spain v2</div></td>
|
||
<td class="num">{{Amount(spainCsv.SalesPriceValue)}}</td>
|
||
<td class="num">{{Amount(spainCsv.ReferenceValue)}}</td>
|
||
<td class="num">{{Amount(spainCsv.Difference)}}</td>
|
||
<td>SalesPriceValue aus Spain_Sales_2025.csv</td>
|
||
<td class="wrap">EUR Hauswaehrung. CHF ueber Budgetkurs 2025.</td>
|
||
<td class="wrap">Export technisch lesbar, aber noch Differenz. Klaeren: Datumsabgrenzung, Serien REG/LAT/PRO/REC und Gutschriften.</td>
|
||
</tr>
|
||
""";
|
||
}
|
||
|
||
static string BuildCurrencyNote(NetSalesReferenceRow row)
|
||
{
|
||
var actualCurrency = row.ActualCurrency.Trim();
|
||
var currencies = row.Currencies.Trim();
|
||
|
||
if (string.IsNullOrWhiteSpace(actualCurrency) && string.IsNullOrWhiteSpace(currencies))
|
||
return "Waehrung noch nicht belegt.";
|
||
|
||
if (actualCurrency.Contains("CHF", StringComparison.OrdinalIgnoreCase) &&
|
||
!actualCurrency.Contains(',', StringComparison.Ordinal))
|
||
{
|
||
return "CHF direkt aus Quelle.";
|
||
}
|
||
|
||
if (actualCurrency.Contains(',', StringComparison.Ordinal) || currencies.Contains(',', StringComparison.Ordinal))
|
||
return $"Gemischte Quellwaehrungen ({PreferNonBlank(actualCurrency, currencies)}). Fachlich ist Hauswaehrung fuehrend; Mapping/Quelle pruefen.";
|
||
|
||
return $"{PreferNonBlank(actualCurrency, currencies)} Hauswaehrung. CHF ueber Budgetkurs 2025.";
|
||
}
|
||
|
||
static string BuildExecutiveReason(NetSalesReferenceRow row, GermanyExcelProbe? germanySample)
|
||
{
|
||
if (row.Key.Equals("DE", StringComparison.OrdinalIgnoreCase) && germanySample is not null)
|
||
{
|
||
return $"DE-Beispielfile gefunden und lesbar: {germanySample.RowsWithAmount} Betragszeilen, Summe {Amount(germanySample.SalesPriceValue)} {germanySample.Currencies}. Das ist ein Sample, kein finaler Jahresexport.";
|
||
}
|
||
|
||
if (row.Status == "OK")
|
||
return "Passt rechnerisch gegen check.xlsx. Hauswaehrung ist fachlich fuehrend.";
|
||
|
||
if (row.Status == "Keine Daten")
|
||
return "Keine belastbaren Daten im Import. Standort/Export/Mapping pruefen.";
|
||
|
||
if (row.DifferenceExcludingIntercompany.HasValue &&
|
||
Math.Abs(row.DifferenceExcludingIntercompany.Value) <= 1m)
|
||
{
|
||
return "Differenz ist nach 2nd-party/Intercompany-Abzug rechnerisch erklaerbar. IC-Kunden sollen spaeter als eigenes Feld gepflegt werden.";
|
||
}
|
||
|
||
if (row.Candidates.Count > 1)
|
||
return "Mehrere technische Summen sichtbar. Gewaehlter Wert folgt der Fachregel: Hauswaehrung / Nettofakturawert.";
|
||
|
||
return "Differenz offen. Quelle, Periodenabgrenzung, Gutschriften und 2nd-party/3rd-party-Abgrenzung pruefen.";
|
||
}
|
||
|
||
static string PreferNonBlank(string first, string second)
|
||
=> !string.IsNullOrWhiteSpace(first) ? first : second;
|
||
|
||
static string BuildGermanySampleSection(
|
||
GermanyExcelProbe? germanySample,
|
||
IReadOnlyDictionary<string, CheckedExcelReference> excelReferences)
|
||
{
|
||
if (germanySample is null)
|
||
{
|
||
return """
|
||
<section id="germany-sample" class="metric" style="margin-top:14px;">
|
||
<strong>Germany Excel</strong>
|
||
<span>Keine DE_Beispiel_Export_Daten.xlsx im Repo gefunden.</span>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
excelReferences.TryGetValue("Trafag DE", out var reference);
|
||
var referenceValue = reference?.PowerBiValue ?? reference?.LocalCurrencyValue;
|
||
var difference = referenceValue.HasValue ? germanySample.SalesPriceValue - referenceValue.Value : (decimal?)null;
|
||
|
||
return $$"""
|
||
<section id="germany-sample" style="margin-top:18px;">
|
||
<h2 style="font-size:18px;margin:0 0 8px;">Germany Excel sample check</h2>
|
||
<div class="summary">
|
||
<div class="metric"><strong>{{germanySample.RowsWithAmount}}</strong><span>Betragszeilen</span></div>
|
||
<div class="metric"><strong>{{Amount(germanySample.SalesPriceValue)}}</strong><span>NettoPreisGesamtX {{Html(germanySample.Currencies)}}</span></div>
|
||
<div class="metric"><strong>{{Amount(referenceValue)}}</strong><span>check.xlsx DE Referenz</span></div>
|
||
<div class="metric"><strong>{{Amount(difference)}}</strong><span>Differenz nur Sample</span></div>
|
||
</div>
|
||
<div class="small">Datei: {{Html(germanySample.Path)}}</div>
|
||
<div class="small">Interpretation: Mapping funktioniert technisch. Diese Datei heisst Beispielfile und enthaelt nur {{germanySample.RowsWithAmount}} Betragszeilen; sie darf deshalb nicht als finale Deutschland-Jahreszahl verwendet werden.</div>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
static string BuildSpainCsvSection(SpainSalesCsvProbe? spainCsv)
|
||
{
|
||
if (spainCsv is null)
|
||
{
|
||
return """
|
||
<section id="spain-csv" class="metric" style="margin-top:14px;">
|
||
<strong>Spain CSV</strong>
|
||
<span>Keine Spain_Sales_2025.csv im Repo gefunden.</span>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
var documentRows = string.Join(Environment.NewLine, spainCsv.ByDocumentType.Select(group => $$"""
|
||
<tr><td>{{Html(group.Label)}}</td><td class="num">{{group.Rows}}</td><td class="num">{{Amount(group.Sales)}}</td></tr>
|
||
"""));
|
||
var seriesRows = string.Join(Environment.NewLine, spainCsv.BySeries.Select(group => $$"""
|
||
<tr><td>{{Html(group.Label)}}</td><td class="num">{{group.Rows}}</td><td class="num">{{Amount(group.Sales)}}</td></tr>
|
||
"""));
|
||
|
||
return $$"""
|
||
<section id="spain-csv" style="margin-top:18px;">
|
||
<h2 style="font-size:18px;margin:0 0 8px;">Spain CSV direct check</h2>
|
||
<div class="summary">
|
||
<div class="metric"><strong>{{spainCsv.Rows}}</strong><span>CSV-Zeilen</span></div>
|
||
<div class="metric"><strong>{{Amount(spainCsv.SalesPriceValue)}}</strong><span>SalesPriceValue EUR</span></div>
|
||
<div class="metric"><strong>{{Amount(spainCsv.ReferenceValue)}}</strong><span>check.xlsx ES</span></div>
|
||
<div class="metric"><strong>{{Amount(spainCsv.Difference)}}</strong><span>Differenz</span></div>
|
||
</div>
|
||
<div class="small">Datei: {{Html(spainCsv.Path)}}</div>
|
||
<div class="table-wrap" style="margin-top:10px;">
|
||
<table>
|
||
<thead><tr><th>DocumentType</th><th class="num">Zeilen</th><th class="num">Sales</th></tr></thead>
|
||
<tbody>{{documentRows}}</tbody>
|
||
</table>
|
||
</div>
|
||
<div class="table-wrap" style="margin-top:10px;">
|
||
<table>
|
||
<thead><tr><th>InvoiceSeries</th><th class="num">Zeilen</th><th class="num">Sales</th></tr></thead>
|
||
<tbody>{{seriesRows}}</tbody>
|
||
</table>
|
||
</div>
|
||
</section>
|
||
""";
|
||
}
|
||
|
||
static string BuildRow(NetSalesReferenceRow row, IReadOnlyDictionary<string, CheckedExcelReference> excelReferences)
|
||
{
|
||
var statusClass = row.Status.Replace(" ", string.Empty);
|
||
excelReferences.TryGetValue(row.Label, out var excelReference);
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><span class="status {{Html(statusClass)}}">{{Html(row.Status)}}</span></td>
|
||
<td><strong>{{Html(row.Label)}}</strong><div class="small">{{Html(row.Key)}} / {{Html(row.ReferenceSource)}}</div></td>
|
||
<td>{{Html(row.ValueField)}}</td>
|
||
<td>{{Html(row.ActualCurrency)}}</td>
|
||
<td class="num">{{Amount(row.ActualValue)}}</td>
|
||
<td>{{Html(row.ReferenceCurrency)}}</td>
|
||
<td class="num">{{Amount(row.ReferenceValue)}}</td>
|
||
<td class="num">{{Amount(excelReference?.LocalCurrencyValue)}}</td>
|
||
<td class="num">{{Amount(excelReference?.ChfValue)}}</td>
|
||
<td class="num">{{Amount(excelReference?.PowerBiValue)}}</td>
|
||
<td>{{Html(excelReference?.Status)}}</td>
|
||
<td class="num">{{Amount(row.Difference)}}</td>
|
||
<td class="num">{{Amount(row.DifferenceExcludingIntercompany)}}</td>
|
||
<td>{{Html(row.Currencies)}}</td>
|
||
<td class="num">{{row.RowCount}}</td>
|
||
<td>{{BuildCandidateDetails(row)}}</td>
|
||
</tr>
|
||
""";
|
||
}
|
||
|
||
static string BuildSpainDetailRow(SpainSalesCsvProbe spainCsv, CheckedExcelReference? excelReference)
|
||
{
|
||
var status = Math.Abs(spainCsv.Difference) <= 1m ? "OK" : "Pruefen";
|
||
|
||
return $$"""
|
||
<tr>
|
||
<td><span class="status {{status}}">{{status}}</span></td>
|
||
<td><strong>Trafag ES</strong><div class="small">ES / Sage Spain v2 CSV</div></td>
|
||
<td>SalesPriceValue CSV</td>
|
||
<td>EUR</td>
|
||
<td class="num">{{Amount(spainCsv.SalesPriceValue)}}</td>
|
||
<td>LC</td>
|
||
<td class="num">{{Amount(spainCsv.ReferenceValue)}}</td>
|
||
<td class="num">{{Amount(excelReference?.LocalCurrencyValue)}}</td>
|
||
<td class="num">{{Amount(excelReference?.ChfValue)}}</td>
|
||
<td class="num">{{Amount(excelReference?.PowerBiValue)}}</td>
|
||
<td>{{Html(excelReference?.Status)}}</td>
|
||
<td class="num">{{Amount(spainCsv.Difference)}}</td>
|
||
<td class="num">-</td>
|
||
<td>EUR</td>
|
||
<td class="num">{{spainCsv.Rows}}</td>
|
||
<td><a href="#spain-csv">CSV-Details anzeigen</a></td>
|
||
</tr>
|
||
""";
|
||
}
|
||
|
||
static string BuildCandidateDetails(NetSalesReferenceRow row)
|
||
{
|
||
if (row.Candidates.Count == 0)
|
||
return "<span class=\"small\">Keine Varianten</span>";
|
||
|
||
var candidateRows = string.Join(Environment.NewLine, row.Candidates.Select(candidate => $$"""
|
||
<tr>
|
||
<td>{{Html(candidate.Label)}}</td>
|
||
<td>{{Html(candidate.Currency)}}</td>
|
||
<td class="num">{{Amount(candidate.Value)}}</td>
|
||
<td class="num">{{Amount(candidate.Difference)}}</td>
|
||
<td class="num">{{Amount(candidate.IntercompanyValue)}}</td>
|
||
<td class="num">{{Amount(candidate.DifferenceExcludingIntercompany)}}</td>
|
||
</tr>
|
||
"""));
|
||
|
||
return $$"""
|
||
<details>
|
||
<summary>{{row.Candidates.Count}} Varianten anzeigen</summary>
|
||
<table class="candidate-table">
|
||
<thead>
|
||
<tr>
|
||
<th>Abgrenzung</th>
|
||
<th>Waehrung</th>
|
||
<th class="num">Wert</th>
|
||
<th class="num">Diff.</th>
|
||
<th class="num">2nd-party/IC</th>
|
||
<th class="num">Diff. ohne 2nd-party</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>{{candidateRows}}</tbody>
|
||
</table>
|
||
</details>
|
||
""";
|
||
}
|
||
|
||
static string Amount(decimal? value)
|
||
=> value.HasValue ? value.Value.ToString("#,##0.00", CultureInfo.GetCultureInfo("de-CH")) : "-";
|
||
|
||
static string Html(string? value)
|
||
=> WebUtility.HtmlEncode(value ?? string.Empty);
|
||
|
||
sealed record FinanceChiefIssue(
|
||
string Status,
|
||
string Label,
|
||
string Key,
|
||
string Currency,
|
||
decimal? ActualValue,
|
||
decimal? ReferenceValue,
|
||
decimal? Difference,
|
||
string Reason,
|
||
decimal SortValue);
|
||
|
||
sealed class CheckedExcelReference
|
||
{
|
||
public string Label { get; set; } = string.Empty;
|
||
public decimal? LocalCurrencyValue { get; set; }
|
||
public decimal? ChfValue { get; set; }
|
||
public decimal? PowerBiValue { get; set; }
|
||
public string Status { get; set; } = string.Empty;
|
||
}
|
||
|
||
sealed class SpainSalesCsvProbe
|
||
{
|
||
public string Path { get; set; } = string.Empty;
|
||
public int Rows { get; set; }
|
||
public decimal SalesPriceValue { get; set; }
|
||
public decimal ReferenceValue { get; set; }
|
||
public decimal Difference { get; set; }
|
||
public List<SpainSalesCsvGroup> ByDocumentType { get; set; } = [];
|
||
public List<SpainSalesCsvGroup> BySeries { get; set; } = [];
|
||
}
|
||
|
||
sealed record SpainSalesCsvGroup(string Label, int Rows, decimal Sales);
|
||
|
||
sealed class GermanyExcelProbe
|
||
{
|
||
public string Path { get; set; } = string.Empty;
|
||
public int RowsWithAmount { get; set; }
|
||
public decimal SalesPriceValue { get; set; }
|
||
public int RowsIn2025 { get; set; }
|
||
public decimal SalesPriceValueIn2025 { get; set; }
|
||
public string Currencies { get; set; } = string.Empty;
|
||
}
|
||
|
||
sealed class SiteCoverageRow
|
||
{
|
||
public string Land { get; set; } = string.Empty;
|
||
public string Tsc { get; set; } = string.Empty;
|
||
public string SourceSystem { get; set; } = string.Empty;
|
||
public string SourceDisplayName { get; set; } = string.Empty;
|
||
public string ConnectionKind { get; set; } = string.Empty;
|
||
public bool IsActive { get; set; }
|
||
public string ManualImportPath { get; set; } = string.Empty;
|
||
public int RowCount { get; set; }
|
||
public decimal? SalesPriceValue { get; set; }
|
||
public DateTime? MinDate { get; set; }
|
||
public DateTime? MaxDate { get; set; }
|
||
public string Currencies { get; set; } = string.Empty;
|
||
public string LastExportStatus { get; set; } = string.Empty;
|
||
public DateTime? LastExportAt { get; set; }
|
||
public string LastExportError { get; set; } = string.Empty;
|
||
}
|