476 lines
21 KiB
C#
476 lines
21 KiB
C#
using ClosedXML.Excel;
|
|
using TrafagSalesExporter.Models;
|
|
|
|
namespace TrafagSalesExporter.Services;
|
|
|
|
public class ExcelExportService : IExcelExportService
|
|
{
|
|
private const int GermanyAlphaplanFinanceYear = 2025;
|
|
|
|
public string CreateExcelFile(string outputDirectory, string tsc, DateTime fileDate, List<SalesRecord> records)
|
|
{
|
|
Directory.CreateDirectory(outputDirectory);
|
|
var fileName = $"Sales_{tsc}_{fileDate:yyyy-MM-dd}.xlsx";
|
|
var fullPath = Path.Combine(outputDirectory, fileName);
|
|
WriteWorkbook(fullPath, records, includeFinanceHelpSheet: false);
|
|
return fullPath;
|
|
}
|
|
|
|
public string CreateConsolidatedExcelFile(string outputDirectory, DateTime fileDate, List<SalesRecord> records)
|
|
{
|
|
Directory.CreateDirectory(outputDirectory);
|
|
var fileName = $"Sales_All_{fileDate:yyyy-MM-dd}.xlsx";
|
|
var fullPath = Path.Combine(outputDirectory, fileName);
|
|
WriteWorkbook(fullPath, records, includeFinanceHelpSheet: true);
|
|
return fullPath;
|
|
}
|
|
|
|
public string CreateGenericExcelFile(string outputDirectory, string filePrefix, DateTime fileDate, string worksheetName, IReadOnlyList<IReadOnlyDictionary<string, object?>> rows)
|
|
{
|
|
Directory.CreateDirectory(outputDirectory);
|
|
var safePrefix = string.IsNullOrWhiteSpace(filePrefix) ? "Export" : filePrefix.Trim();
|
|
var fileName = $"{safePrefix}_{fileDate:yyyy-MM-dd}.xlsx";
|
|
var fullPath = Path.Combine(outputDirectory, fileName);
|
|
WriteGenericWorkbook(fullPath, worksheetName, rows);
|
|
return fullPath;
|
|
}
|
|
|
|
private static void WriteWorkbook(string fullPath, List<SalesRecord> records, bool includeFinanceHelpSheet)
|
|
{
|
|
using var workbook = new XLWorkbook();
|
|
var ws = workbook.Worksheets.Add("Sales");
|
|
|
|
var headers = new[]
|
|
{
|
|
"extraction date",
|
|
"TSC",
|
|
"Document Entry",
|
|
"Invoice Number",
|
|
"Position on invoice",
|
|
"Material",
|
|
"Name",
|
|
"Product Group",
|
|
"Quantity",
|
|
"Supplier number",
|
|
"Supplier name",
|
|
"Supplier country",
|
|
"Customer number",
|
|
"Customer name",
|
|
"Customer country",
|
|
"Customer Industry",
|
|
"Standard cost",
|
|
"Standard Cost Currency",
|
|
"Purchase Order number",
|
|
"Sales Price/Value",
|
|
"Sales Currency",
|
|
"Document Currency",
|
|
"Document Total FC",
|
|
"Document Total LC",
|
|
"VAT Sum FC",
|
|
"VAT Sum LC",
|
|
"Document Rate",
|
|
"Company Currency",
|
|
"Incoterms 2020",
|
|
"Sales responsible employee",
|
|
"posting date",
|
|
"invoice date",
|
|
"order date",
|
|
"Land",
|
|
"Document Type",
|
|
"Finance | Year",
|
|
"Finance | Country Key",
|
|
"Finance | Date",
|
|
"Finance | Net Sales Actual",
|
|
"Finance | Currency",
|
|
"Finance | Include",
|
|
"Finance | Source Value Field"
|
|
};
|
|
|
|
for (var i = 0; i < headers.Length; i++)
|
|
{
|
|
ws.Cell(1, i + 1).Value = headers[i];
|
|
ws.Cell(1, i + 1).Style.Font.Bold = true;
|
|
}
|
|
|
|
var row = 2;
|
|
var italyBlankSupplierCountryRows = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var record in records)
|
|
{
|
|
ws.Cell(row, 1).Value = record.ExtractionDate.ToString("dd.MM.yyyy HH:mm:ss");
|
|
ws.Cell(row, 2).Value = record.Tsc;
|
|
ws.Cell(row, 3).Value = record.DocumentEntry;
|
|
ws.Cell(row, 4).Value = record.InvoiceNumber;
|
|
ws.Cell(row, 5).Value = record.PositionOnInvoice;
|
|
ws.Cell(row, 6).Value = record.Material;
|
|
ws.Cell(row, 7).Value = record.Name;
|
|
ws.Cell(row, 8).Value = record.ProductGroup;
|
|
ws.Cell(row, 9).Value = record.Quantity;
|
|
ws.Cell(row, 10).Value = record.SupplierNumber;
|
|
ws.Cell(row, 11).Value = record.SupplierName;
|
|
ws.Cell(row, 12).Value = record.SupplierCountry;
|
|
ws.Cell(row, 13).Value = record.CustomerNumber;
|
|
ws.Cell(row, 14).Value = record.CustomerName;
|
|
ws.Cell(row, 15).Value = record.CustomerCountry;
|
|
ws.Cell(row, 16).Value = record.CustomerIndustry;
|
|
ws.Cell(row, 17).Value = record.StandardCost;
|
|
ws.Cell(row, 18).Value = record.StandardCostCurrency;
|
|
ws.Cell(row, 19).Value = record.PurchaseOrderNumber;
|
|
ws.Cell(row, 20).Value = record.SalesPriceValue;
|
|
ws.Cell(row, 21).Value = record.SalesCurrency;
|
|
ws.Cell(row, 22).Value = record.DocumentCurrency;
|
|
ws.Cell(row, 23).Value = record.DocumentTotalForeignCurrency;
|
|
ws.Cell(row, 24).Value = record.DocumentTotalLocalCurrency;
|
|
ws.Cell(row, 25).Value = record.VatSumForeignCurrency;
|
|
ws.Cell(row, 26).Value = record.VatSumLocalCurrency;
|
|
ws.Cell(row, 27).Value = record.DocumentRate;
|
|
ws.Cell(row, 28).Value = record.CompanyCurrency;
|
|
ws.Cell(row, 29).Value = record.Incoterms2020;
|
|
ws.Cell(row, 30).Value = record.SalesResponsibleEmployee;
|
|
ws.Cell(row, 31).Value = record.PostingDate?.ToString("dd.MM.yyyy") ?? string.Empty;
|
|
ws.Cell(row, 32).Value = record.InvoiceDate?.ToString("dd.MM.yyyy") ?? string.Empty;
|
|
ws.Cell(row, 33).Value = record.OrderDate?.ToString("dd.MM.yyyy") ?? string.Empty;
|
|
ws.Cell(row, 34).Value = record.Land;
|
|
ws.Cell(row, 35).Value = record.DocumentType;
|
|
var financeDate = ResolveFinanceDate(record);
|
|
var financeCountryKey = ResolveFinanceCountryKey(record.Land, record.Tsc);
|
|
var financeInclude = ResolveFinanceInclude(record, financeCountryKey, italyBlankSupplierCountryRows);
|
|
var financeNetSalesActual = ResolveFinanceNetSalesActual(record, financeCountryKey, financeInclude);
|
|
ws.Cell(row, 36).Value = financeDate.Year;
|
|
ws.Cell(row, 37).Value = financeCountryKey;
|
|
ws.Cell(row, 38).Value = financeDate.ToString("dd.MM.yyyy");
|
|
ws.Cell(row, 39).Value = financeNetSalesActual;
|
|
ws.Cell(row, 40).Value = ResolveFinanceCurrency(record);
|
|
ws.Cell(row, 41).Value = financeInclude && financeNetSalesActual != 0m ? "TRUE" : "FALSE";
|
|
ws.Cell(row, 42).Value = financeInclude
|
|
? "Sales Price/Value"
|
|
: ResolveFinanceExclusionReason(record, financeCountryKey);
|
|
row++;
|
|
}
|
|
|
|
ws.Columns().AdjustToContents();
|
|
if (includeFinanceHelpSheet)
|
|
{
|
|
AddFinanceSummarySheet(workbook, records);
|
|
AddFinanceHelpSheet(workbook);
|
|
}
|
|
|
|
workbook.SaveAs(fullPath);
|
|
}
|
|
|
|
private static void AddFinanceSummarySheet(XLWorkbook workbook, List<SalesRecord> records)
|
|
{
|
|
var ws = workbook.Worksheets.Add("Finance Summary");
|
|
ws.Position = 1;
|
|
ws.Cell(1, 1).Value = "Finance Summary";
|
|
ws.Cell(1, 1).Style.Font.Bold = true;
|
|
ws.Cell(1, 1).Style.Font.FontSize = 14;
|
|
ws.Cell(2, 1).Value = "Diese Summen verwenden dieselbe Finance-Sicht wie die Spalten Finance | ... im Blatt Sales.";
|
|
|
|
var headers = new[]
|
|
{
|
|
"Year",
|
|
"Country Key",
|
|
"Currency",
|
|
"Included Rows",
|
|
"Net Sales Actual",
|
|
"Excluded Rows",
|
|
"Hinweis"
|
|
};
|
|
|
|
for (var i = 0; i < headers.Length; i++)
|
|
{
|
|
ws.Cell(4, i + 1).Value = headers[i];
|
|
ws.Cell(4, i + 1).Style.Font.Bold = true;
|
|
}
|
|
|
|
var italyBlankSupplierCountryRows = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
var summaryRows = records
|
|
.Select(record =>
|
|
{
|
|
var financeDate = ResolveFinanceDate(record);
|
|
var countryKey = ResolveFinanceCountryKey(record.Land, record.Tsc);
|
|
var rawInclude = ResolveFinanceInclude(record, countryKey, italyBlankSupplierCountryRows);
|
|
var value = ResolveFinanceNetSalesActual(record, countryKey, rawInclude);
|
|
var include = rawInclude && value != 0m;
|
|
return new
|
|
{
|
|
Year = financeDate.Year,
|
|
CountryKey = countryKey,
|
|
Currency = ResolveFinanceCurrency(record),
|
|
Include = include,
|
|
Value = value
|
|
};
|
|
})
|
|
.GroupBy(row => new { row.Year, row.CountryKey, row.Currency })
|
|
.OrderBy(group => group.Key.Year)
|
|
.ThenBy(group => group.Key.CountryKey, StringComparer.OrdinalIgnoreCase)
|
|
.ThenBy(group => group.Key.Currency, StringComparer.OrdinalIgnoreCase)
|
|
.Select(group => new
|
|
{
|
|
group.Key.Year,
|
|
group.Key.CountryKey,
|
|
group.Key.Currency,
|
|
IncludedRows = group.Count(row => row.Include),
|
|
NetSalesActual = group.Sum(row => row.Value),
|
|
ExcludedRows = group.Count(row => !row.Include)
|
|
})
|
|
.ToList();
|
|
|
|
var rowIndex = 5;
|
|
foreach (var row in summaryRows)
|
|
{
|
|
ws.Cell(rowIndex, 1).Value = row.Year;
|
|
ws.Cell(rowIndex, 2).Value = row.CountryKey;
|
|
ws.Cell(rowIndex, 3).Value = row.Currency;
|
|
ws.Cell(rowIndex, 4).Value = row.IncludedRows;
|
|
ws.Cell(rowIndex, 5).Value = row.NetSalesActual;
|
|
ws.Cell(rowIndex, 6).Value = row.ExcludedRows;
|
|
ws.Cell(rowIndex, 7).Value = BuildFinanceSummaryHint(row.CountryKey);
|
|
rowIndex++;
|
|
}
|
|
|
|
ws.Column(5).Style.NumberFormat.Format = "#,##0.00";
|
|
ws.Columns().AdjustToContents();
|
|
}
|
|
|
|
private static string BuildFinanceSummaryHint(string countryKey)
|
|
=> countryKey.ToUpperInvariant() switch
|
|
{
|
|
"DE" => "DE Alphaplan Jahresfile 2025: Weiterberechnungen ausgeschlossen; GS negativ, GS2510095 2024.",
|
|
"IT" => "IT: Trafag Italia ausgeschlossen; doppelte Blank-Supplier-Zeilen nur einmal.",
|
|
"UK" => "UK: Sage/Manual Excel, Credit Notes negativ.",
|
|
"ES" => "ES: Sage CSV/Manual Excel, REC/Credit Notes negativ.",
|
|
_ => string.Empty
|
|
};
|
|
|
|
private static void AddFinanceHelpSheet(XLWorkbook workbook)
|
|
{
|
|
var ws = workbook.Worksheets.Add("Finance Filter Hilfe");
|
|
ws.Cell(1, 1).Value = "Finance-Filter fuer Soll/Ist-Abgleich";
|
|
ws.Cell(1, 1).Style.Font.Bold = true;
|
|
ws.Cell(1, 1).Style.Font.FontSize = 14;
|
|
|
|
var rows = new (string Label, string Value)[]
|
|
{
|
|
("Ziel", "Diese Spalten bilden im Blatt Sales die zusammengehoerige Finance-Sicht fuer den Abgleich gegen check.xlsx."),
|
|
("1. Jahr filtern", "Finance | Year = gewuenschtes Jahr, z.B. 2025"),
|
|
("2. Land filtern", "Finance | Country Key = CH, AT, DE, ES, FR, IN, IT, UK oder US"),
|
|
("3. Gueltige Zeilen filtern", "Finance | Include = TRUE"),
|
|
("4. Summe bilden", "Finance | Net Sales Actual summieren"),
|
|
("Waehrung", "Finance | Currency zeigt die fuer den Finance-Abgleich fuehrende Hauswaehrung."),
|
|
("Datum", "Finance | Date verwendet PostingDate, danach InvoiceDate, danach ExtractionDate. DE Alphaplan wird als Jahresfile 2025 behandelt."),
|
|
("Wertquelle", "Finance | Source Value Field zeigt, aus welchem Rohfeld der Finance-Wert kommt."),
|
|
("DE-Sonderregel", "Fuer DE gilt die Deutschland-Rueckmeldung: Trafag AG und Magnetic Sense ausgeschlossen, GS-Gutschriften negativ, GS2510095 nicht in 2025."),
|
|
("IT-Sonderregel", "Fuer IT wird Trafag Italia im Finance-Wert ausgeschlossen; doppelte IT-Zeilen ohne Supplier country werden nur einmal gezaehlt."),
|
|
("Nicht verwenden", "Nicht Land, TSC, Document Total LC oder andere Betragsspalten fuer den CFO-Abgleich erraten."),
|
|
("Hinweis", "Offene fachliche Differenzen bleiben sichtbar; diese Excel-Sicht soll die gleiche Ist-Summe wie das Testprogramm reproduzieren.")
|
|
};
|
|
|
|
ws.Cell(3, 1).Value = "Feld";
|
|
ws.Cell(3, 2).Value = "Anwendung";
|
|
ws.Range(3, 1, 3, 2).Style.Font.Bold = true;
|
|
|
|
for (var i = 0; i < rows.Length; i++)
|
|
{
|
|
ws.Cell(i + 4, 1).Value = rows[i].Label;
|
|
ws.Cell(i + 4, 2).Value = rows[i].Value;
|
|
}
|
|
|
|
var financeColumns = new[]
|
|
{
|
|
"Finance | Year",
|
|
"Finance | Country Key",
|
|
"Finance | Date",
|
|
"Finance | Net Sales Actual",
|
|
"Finance | Currency",
|
|
"Finance | Include",
|
|
"Finance | Source Value Field"
|
|
};
|
|
|
|
var startRow = rows.Length + 6;
|
|
ws.Cell(startRow, 1).Value = "Zusammengehoerige Spalten im Blatt Sales";
|
|
ws.Cell(startRow, 1).Style.Font.Bold = true;
|
|
for (var i = 0; i < financeColumns.Length; i++)
|
|
{
|
|
ws.Cell(startRow + 1 + i, 1).Value = financeColumns[i];
|
|
}
|
|
|
|
ws.Columns().AdjustToContents();
|
|
}
|
|
|
|
private static DateTime ResolveFinanceDate(SalesRecord record)
|
|
{
|
|
var countryKey = ResolveFinanceCountryKey(record.Land, record.Tsc);
|
|
if (countryKey.Equals("DE", StringComparison.OrdinalIgnoreCase))
|
|
return new DateTime(GermanyAlphaplanFinanceYear, 12, 31);
|
|
|
|
return record.PostingDate ?? record.InvoiceDate ?? record.ExtractionDate;
|
|
}
|
|
|
|
private static string ResolveFinanceCurrency(SalesRecord record)
|
|
=> ResolveFinanceCountryKey(record.Land, record.Tsc) switch
|
|
{
|
|
"CH" => "CHF",
|
|
"AT" => "EUR",
|
|
"DE" => "EUR",
|
|
"ES" => "EUR",
|
|
"FR" => "EUR",
|
|
"IN" => "INR",
|
|
"IT" => "EUR",
|
|
"UK" => "GBP",
|
|
"US" => "USD",
|
|
_ => string.IsNullOrWhiteSpace(record.CompanyCurrency) ? record.SalesCurrency : record.CompanyCurrency
|
|
};
|
|
|
|
private static string ResolveFinanceCountryKey(string land, string tsc)
|
|
{
|
|
var normalizedLand = (land ?? string.Empty).Trim().ToUpperInvariant();
|
|
var normalizedTsc = (tsc ?? string.Empty).Trim().ToUpperInvariant();
|
|
|
|
if (normalizedLand is "AT" or "AUT" || normalizedLand.Contains("OESTER") || normalizedLand.Contains("OSTER") || normalizedLand.Contains("AUSTRIA")) return "AT";
|
|
if (normalizedLand is "CH" or "CHE" || normalizedLand.Contains("SCHWE") || normalizedLand.Contains("SWITZER")) return "CH";
|
|
if (normalizedLand.Contains("FRANK") || normalizedTsc.Contains("FR")) return "FR";
|
|
if (normalizedLand.Contains("IND") || normalizedTsc.Contains("IN")) return "IN";
|
|
if (normalizedLand.Contains("ITAL") || normalizedTsc.Contains("IT")) return "IT";
|
|
if (normalizedLand.Contains("ENGL") || normalizedLand.Contains("KINGDOM") || normalizedTsc.Contains("UK") || normalizedTsc.Contains("GB")) return "UK";
|
|
if (normalizedLand.Contains("USA") || normalizedLand.Contains("UNITED STATES") || normalizedTsc.Contains("US")) return "US";
|
|
if (normalizedLand.Contains("DEUT") || normalizedTsc.Contains("DE")) return "DE";
|
|
if (normalizedLand.Contains("SPAN") || normalizedTsc is "SE" or "ES") return "ES";
|
|
|
|
return normalizedTsc.Replace("TR", string.Empty);
|
|
}
|
|
|
|
private static bool ResolveFinanceInclude(SalesRecord record, string financeCountryKey, HashSet<string> italyBlankSupplierCountryRows)
|
|
{
|
|
if (financeCountryKey.Equals("DE", StringComparison.OrdinalIgnoreCase))
|
|
return IsIncludedGermanyFinanceRow(record);
|
|
|
|
if (!financeCountryKey.Equals("IT", StringComparison.OrdinalIgnoreCase))
|
|
return true;
|
|
|
|
if (IsExcludedItalyCustomer(record))
|
|
return false;
|
|
|
|
if (!string.IsNullOrWhiteSpace(record.SupplierCountry))
|
|
return true;
|
|
|
|
return italyBlankSupplierCountryRows.Add(BuildItalyBlankSupplierCountryDeduplicationKey(record));
|
|
}
|
|
|
|
private static string ResolveFinanceExclusionReason(SalesRecord record, string financeCountryKey)
|
|
{
|
|
if (financeCountryKey.Equals("IT", StringComparison.OrdinalIgnoreCase) && IsExcludedItalyCustomer(record))
|
|
return "Excluded IT customer: Trafag Italia";
|
|
|
|
if (financeCountryKey.Equals("IT", StringComparison.OrdinalIgnoreCase) && string.IsNullOrWhiteSpace(record.SupplierCountry))
|
|
return "Excluded IT duplicate without Supplier country";
|
|
|
|
if (financeCountryKey.Equals("DE", StringComparison.OrdinalIgnoreCase))
|
|
return ResolveGermanyExclusionReason(record);
|
|
|
|
return "Excluded";
|
|
}
|
|
|
|
private static decimal ResolveFinanceNetSalesActual(SalesRecord record, string financeCountryKey, bool financeInclude)
|
|
{
|
|
if (!financeInclude)
|
|
return 0m;
|
|
|
|
if (financeCountryKey.Equals("DE", StringComparison.OrdinalIgnoreCase) && IsGermanyCreditNote(record))
|
|
return -Math.Abs(record.SalesPriceValue);
|
|
|
|
return record.SalesPriceValue;
|
|
}
|
|
|
|
private static bool IsIncludedGermanyFinanceRow(SalesRecord record)
|
|
=> !IsGermanyTrafagAgRecharge(record) &&
|
|
!IsGermanyMagneticSenseRecharge(record) &&
|
|
!IsGermanyCreditNoteAlreadyCapturedInPriorYear(record);
|
|
|
|
private static string ResolveGermanyExclusionReason(SalesRecord record)
|
|
{
|
|
if (IsGermanyTrafagAgRecharge(record))
|
|
return "Excluded DE Weiterberechnung Trafag AG";
|
|
if (IsGermanyMagneticSenseRecharge(record))
|
|
return "Excluded DE Weiterberechnung Magnetic Sense";
|
|
if (IsGermanyCreditNoteAlreadyCapturedInPriorYear(record))
|
|
return "Excluded DE GS2510095 already captured in 2024";
|
|
|
|
return "Excluded DE";
|
|
}
|
|
|
|
private static bool IsGermanyTrafagAgRecharge(SalesRecord record)
|
|
=> NormalizeFinanceText(record.CustomerName) == "TRAFAG AG";
|
|
|
|
private static bool IsGermanyMagneticSenseRecharge(SalesRecord record)
|
|
=> NormalizeFinanceText(record.CustomerName).Contains("MAGNETIC SENSE", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static bool IsGermanyCreditNote(SalesRecord record)
|
|
=> (record.InvoiceNumber ?? string.Empty).Trim().StartsWith("GS", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static bool IsGermanyCreditNoteAlreadyCapturedInPriorYear(SalesRecord record)
|
|
=> (record.InvoiceNumber ?? string.Empty).Trim().Equals("GS2510095", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static bool IsExcludedItalyCustomer(SalesRecord record)
|
|
=> NormalizeFinanceText(record.CustomerName).Contains("TRAFAG ITALIA", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static string BuildItalyBlankSupplierCountryDeduplicationKey(SalesRecord record)
|
|
=> string.Join("|",
|
|
record.Tsc,
|
|
record.DocumentType,
|
|
record.DocumentEntry,
|
|
record.InvoiceNumber,
|
|
record.PositionOnInvoice,
|
|
record.Material,
|
|
record.Name,
|
|
record.Quantity,
|
|
record.CustomerNumber,
|
|
record.CustomerName,
|
|
record.SalesPriceValue,
|
|
record.DocumentTotalForeignCurrency,
|
|
record.DocumentTotalLocalCurrency,
|
|
record.VatSumForeignCurrency,
|
|
record.VatSumLocalCurrency,
|
|
record.PostingDate?.ToString("O") ?? string.Empty,
|
|
record.InvoiceDate?.ToString("O") ?? string.Empty);
|
|
|
|
private static string NormalizeFinanceText(string value)
|
|
=> (value ?? string.Empty)
|
|
.Replace("\u00e4", "ae", StringComparison.OrdinalIgnoreCase)
|
|
.Replace("\u00f6", "oe", StringComparison.OrdinalIgnoreCase)
|
|
.Replace("\u00fc", "ue", StringComparison.OrdinalIgnoreCase)
|
|
.Trim()
|
|
.ToUpperInvariant();
|
|
|
|
private static void WriteGenericWorkbook(string fullPath, string worksheetName, IReadOnlyList<IReadOnlyDictionary<string, object?>> rows)
|
|
{
|
|
using var workbook = new XLWorkbook();
|
|
var sheetName = string.IsNullOrWhiteSpace(worksheetName) ? "Export" : worksheetName.Trim();
|
|
var ws = workbook.Worksheets.Add(sheetName.Length > 31 ? sheetName[..31] : sheetName);
|
|
|
|
var headers = rows
|
|
.SelectMany(r => r.Keys)
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.ToList();
|
|
|
|
for (var i = 0; i < headers.Count; i++)
|
|
{
|
|
ws.Cell(1, i + 1).Value = headers[i];
|
|
ws.Cell(1, i + 1).Style.Font.Bold = true;
|
|
}
|
|
|
|
for (var rowIndex = 0; rowIndex < rows.Count; rowIndex++)
|
|
{
|
|
var row = rows[rowIndex];
|
|
for (var colIndex = 0; colIndex < headers.Count; colIndex++)
|
|
{
|
|
row.TryGetValue(headers[colIndex], out var value);
|
|
ws.Cell(rowIndex + 2, colIndex + 1).Value = value?.ToString() ?? string.Empty;
|
|
}
|
|
}
|
|
|
|
ws.Columns().AdjustToContents();
|
|
workbook.SaveAs(fullPath);
|
|
}
|
|
}
|