Example: Excel Export Integration

Overview

This example demonstrates the comprehensive Excel export functionality integrated into the AR Payment Reversal dashboard. The system provides flexible, formatted Excel exports of payment reversal data, including dynamic column selection, custom formatting, multiple worksheet support, and template-based reporting for various stakeholder needs.

Business Value

Excel export capabilities address critical business requirements:

• Reporting: Generate formatted reports for management and auditors
• Data Analysis: Enable offline analysis in familiar tools
• Documentation: Create permanent records of reversal activities
• Integration: Share data with other systems via Excel
• Compliance: Provide audit-ready documentation

Implementation Architecture

Excel Service Interface

Core service contract for Excel operations:

// MepApps.Dash.Ar.Maint.PaymentReversal/Services/IExcelExportService.cs
public interface IExcelExportService
{
    Task<byte[]> ExportToExcelAsync<T>(
        IEnumerable<T> data,
        ExcelExportOptions options = null);
    
    Task<byte[]> ExportCompletionReportAsync(
        ArReversePaymentPostCompletion completion,
        ReportOptions options = null);
    
    Task<byte[]> ExportMultiSheetAsync(
        Dictionary<string, object> sheets,
        ExcelExportOptions options = null);
    
    Task<string> SaveExportAsync(
        byte[] excelData,
        string fileName,
        ExportLocation location = ExportLocation.Default);
}

public class ExcelExportOptions
{
    public string WorksheetName { get; set; } = "Data";
    public bool IncludeHeaders { get; set; } = true;
    public bool AutoFitColumns { get; set; } = true;
    public bool ApplyFilters { get; set; } = true;
    public bool FreezePanes { get; set; } = true;
    public List<ExcelColumn> Columns { get; set; }
    public ExcelStyleOptions Styling { get; set; }
    public Dictionary<string, object> Metadata { get; set; }
}

public class ExcelColumn
{
    public string PropertyName { get; set; }
    public string HeaderText { get; set; }
    public int Order { get; set; }
    public bool IsVisible { get; set; } = true;
    public ExcelColumnFormat Format { get; set; }
    public int? Width { get; set; }
    public ExcelAlignment Alignment { get; set; }
    public Func<object, object> Transform { get; set; }
}

public enum ExcelColumnFormat
{
    General,
    Number,
    Currency,
    Percentage,
    Date,
    DateTime,
    Time,
    Text,
    Custom
}

Excel Export Service Implementation

EPPlus-based implementation with advanced formatting:

// MepApps.Dash.Ar.Maint.PaymentReversal/Services/ExcelExportService.cs
public class ExcelExportService : IExcelExportService
{
    private readonly ILogger<ExcelExportService> _logger;
    
    public async Task<byte[]> ExportToExcelAsync<T>(
        IEnumerable<T> data,
        ExcelExportOptions options = null)
    {
        options ??= new ExcelExportOptions();
        
        using (var package = new ExcelPackage())
        {
            var worksheet = package.Workbook.Worksheets.Add(options.WorksheetName);
            
            // Prepare columns
            var columns = PrepareColumns<T>(options);
            
            // Add headers
            if (options.IncludeHeaders)
            {
                AddHeaders(worksheet, columns, options.Styling);
            }
            
            // Add data
            var rowIndex = options.IncludeHeaders ? 2 : 1;
            foreach (var item in data)
            {
                AddDataRow(worksheet, item, columns, rowIndex++, options.Styling);
            }
            
            // Apply formatting
            ApplyFormatting(worksheet, columns, rowIndex - 1, options);
            
            // Add metadata
            if (options.Metadata != null)
            {
                AddMetadata(package, options.Metadata);
            }
            
            _logger.LogInformation("Exported {Count} rows to Excel", data.Count());
            
            return await Task.FromResult(package.GetAsByteArray());
        }
    }
    
    private List<ExcelColumn> PrepareColumns<T>(ExcelExportOptions options)
    {
        List<ExcelColumn> columns;
        
        if (options.Columns?.Any() == true)
        {
            // Use provided columns
            columns = options.Columns
                .Where(c => c.IsVisible)
                .OrderBy(c => c.Order)
                .ToList();
        }
        else
        {
            // Auto-generate columns from properties
            columns = typeof(T).GetProperties()
                .Where(p => p.CanRead && !p.GetCustomAttribute<ExcelIgnoreAttribute>()?.Ignore == true)
                .Select((p, index) => new ExcelColumn
                {
                    PropertyName = p.Name,
                    HeaderText = GetHeaderText(p),
                    Order = GetOrder(p, index),
                    Format = GetFormat(p),
                    Alignment = GetAlignment(p),
                    Width = GetWidth(p)
                })
                .OrderBy(c => c.Order)
                .ToList();
        }
        
        return columns;
    }
    
    private void AddHeaders(
        ExcelWorksheet worksheet,
        List<ExcelColumn> columns,
        ExcelStyleOptions styling)
    {
        for (int i = 0; i < columns.Count; i++)
        {
            var cell = worksheet.Cells[1, i + 1];
            cell.Value = columns[i].HeaderText;
            
            // Apply header styling
            cell.Style.Font.Bold = true;
            cell.Style.Fill.PatternType = ExcelFillStyle.Solid;
            cell.Style.Fill.BackgroundColor.SetColor(
                styling?.HeaderBackgroundColor ?? Color.LightGray);
            cell.Style.Font.Color.SetColor(
                styling?.HeaderTextColor ?? Color.Black);
            cell.Style.Border.BorderAround(ExcelBorderStyle.Thin);
            cell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
            cell.Style.VerticalAlignment = ExcelVerticalAlignment.Center;
        }
    }
    
    private void AddDataRow<T>(
        ExcelWorksheet worksheet,
        T item,
        List<ExcelColumn> columns,
        int rowIndex,
        ExcelStyleOptions styling)
    {
        for (int i = 0; i < columns.Count; i++)
        {
            var column = columns[i];
            var cell = worksheet.Cells[rowIndex, i + 1];
            
            // Get value
            var property = typeof(T).GetProperty(column.PropertyName);
            var value = property?.GetValue(item);
            
            // Apply transformation if specified
            if (column.Transform != null)
            {
                value = column.Transform(value);
            }
            
            // Set cell value
            cell.Value = value;
            
            // Apply formatting
            ApplyCellFormat(cell, column, value, styling);
            
            // Apply conditional formatting
            ApplyConditionalFormat(cell, column, value, styling);
        }
        
        // Apply row-level formatting
        if (rowIndex % 2 == 0 && styling?.AlternateRowColor != null)
        {
            worksheet.Row(rowIndex).Style.Fill.PatternType = ExcelFillStyle.Solid;
            worksheet.Row(rowIndex).Style.Fill.BackgroundColor.SetColor(
                styling.AlternateRowColor.Value);
        }
    }
    
    private void ApplyCellFormat(
        ExcelRangeBase cell,
        ExcelColumn column,
        object value,
        ExcelStyleOptions styling)
    {
        // Apply column format
        switch (column.Format)
        {
            case ExcelColumnFormat.Currency:
                cell.Style.Numberformat.Format = "$#,##0.00";
                break;
                
            case ExcelColumnFormat.Percentage:
                cell.Style.Numberformat.Format = "0.00%";
                break;
                
            case ExcelColumnFormat.Date:
                cell.Style.Numberformat.Format = "mm/dd/yyyy";
                break;
                
            case ExcelColumnFormat.DateTime:
                cell.Style.Numberformat.Format = "mm/dd/yyyy hh:mm:ss";
                break;
                
            case ExcelColumnFormat.Number:
                cell.Style.Numberformat.Format = "#,##0";
                break;
                
            case ExcelColumnFormat.Custom:
                if (!string.IsNullOrEmpty(column.CustomFormat))
                {
                    cell.Style.Numberformat.Format = column.CustomFormat;
                }
                break;
        }
        
        // Apply alignment
        switch (column.Alignment)
        {
            case ExcelAlignment.Left:
                cell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Left;
                break;
                
            case ExcelAlignment.Center:
                cell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
                break;
                
            case ExcelAlignment.Right:
                cell.Style.HorizontalAlignment = ExcelHorizontalAlignment.Right;
                break;
        }
        
        // Apply border
        if (styling?.ShowBorders == true)
        {
            cell.Style.Border.BorderAround(ExcelBorderStyle.Thin);
        }
    }
    
    private void ApplyFormatting(
        ExcelWorksheet worksheet,
        List<ExcelColumn> columns,
        int lastRow,
        ExcelExportOptions options)
    {
        // AutoFit columns
        if (options.AutoFitColumns)
        {
            for (int i = 0; i < columns.Count; i++)
            {
                if (columns[i].Width.HasValue)
                {
                    worksheet.Column(i + 1).Width = columns[i].Width.Value;
                }
                else
                {
                    worksheet.Column(i + 1).AutoFit();
                    
                    // Apply min/max width constraints
                    var width = worksheet.Column(i + 1).Width;
                    if (width < 10) worksheet.Column(i + 1).Width = 10;
                    if (width > 50) worksheet.Column(i + 1).Width = 50;
                }
            }
        }
        
        // Apply filters
        if (options.ApplyFilters && options.IncludeHeaders)
        {
            worksheet.Cells[1, 1, lastRow, columns.Count].AutoFilter = true;
        }
        
        // Freeze panes
        if (options.FreezePanes && options.IncludeHeaders)
        {
            worksheet.View.FreezePanes(2, 1);
        }
        
        // Add print settings
        worksheet.PrinterSettings.RepeatRows = worksheet.Cells["1:1"];
        worksheet.PrinterSettings.PrintArea = worksheet.Cells[1, 1, lastRow, columns.Count];
        worksheet.PrinterSettings.FitToPage = true;
        worksheet.PrinterSettings.FitToWidth = 1;
        worksheet.PrinterSettings.FitToHeight = 0;
    }
}

Completion Report Export

Specialized export for payment reversal completions:

// MepApps.Dash.Ar.Maint.PaymentReversal/Services/ExcelExportService.cs (continued)
public async Task<byte[]> ExportCompletionReportAsync(
    ArReversePaymentPostCompletion completion,
    ReportOptions options = null)
{
    options ??= ReportOptions.Default;
    
    using (var package = new ExcelPackage())
    {
        // Summary worksheet
        var summarySheet = package.Workbook.Worksheets.Add("Summary");
        AddSummarySheet(summarySheet, completion, options);
        
        // Payment details worksheet
        if (completion.Payments?.Any() == true)
        {
            var paymentsSheet = package.Workbook.Worksheets.Add("Payments");
            await AddPaymentsSheet(paymentsSheet, completion.Payments, options);
        }
        
        // Invoice details worksheet
        if (completion.Invoices?.Any() == true)
        {
            var invoicesSheet = package.Workbook.Worksheets.Add("Invoices");
            await AddInvoicesSheet(invoicesSheet, completion.Invoices, options);
        }
        
        // Journal entries worksheet
        if (completion.JournalEntries?.Any() == true)
        {
            var journalSheet = package.Workbook.Worksheets.Add("Journal Entries");
            await AddJournalSheet(journalSheet, completion.JournalEntries, options);
        }
        
        // Errors worksheet (if any)
        if (completion.Errors?.Any() == true)
        {
            var errorsSheet = package.Workbook.Worksheets.Add("Errors");
            AddErrorsSheet(errorsSheet, completion.Errors);
        }
        
        // Add document properties
        package.Workbook.Properties.Title = "AR Payment Reversal Report";
        package.Workbook.Properties.Author = options.Author ?? "System";
        package.Workbook.Properties.Subject = $"Reversal Post Date: {completion.PostDate:yyyy-MM-dd}";
        package.Workbook.Properties.Created = DateTime.Now;
        package.Workbook.Properties.Company = options.CompanyName;
        
        _logger.LogInformation("Generated completion report with {Sheets} worksheets",
            package.Workbook.Worksheets.Count);
        
        return await Task.FromResult(package.GetAsByteArray());
    }
}

private void AddSummarySheet(
    ExcelWorksheet worksheet,
    ArReversePaymentPostCompletion completion,
    ReportOptions options)
{
    // Title
    worksheet.Cells["A1:F1"].Merge = true;
    worksheet.Cells["A1"].Value = "AR Payment Reversal Completion Report";
    worksheet.Cells["A1"].Style.Font.Size = 16;
    worksheet.Cells["A1"].Style.Font.Bold = true;
    worksheet.Cells["A1"].Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
    
    // Company info
    worksheet.Cells["A3"].Value = "Company:";
    worksheet.Cells["B3"].Value = options.CompanyName;
    worksheet.Cells["A4"].Value = "Report Date:";
    worksheet.Cells["B4"].Value = DateTime.Now;
    worksheet.Cells["B4"].Style.Numberformat.Format = "mm/dd/yyyy hh:mm:ss";
    
    // Posting summary
    var row = 6;
    worksheet.Cells[$"A{row}:B{row}"].Style.Font.Bold = true;
    worksheet.Cells[$"A{row}:B{row}"].Style.Fill.PatternType = ExcelFillStyle.Solid;
    worksheet.Cells[$"A{row}:B{row}"].Style.Fill.BackgroundColor.SetColor(Color.LightBlue);
    
    worksheet.Cells[$"A{row}"].Value = "Posting Summary";
    row++;
    
    AddSummaryRow(worksheet, ref row, "Post Date:", completion.PostDate.ToString("yyyy-MM-dd HH:mm:ss"));
    AddSummaryRow(worksheet, ref row, "Post Period:", completion.PostPeriod);
    AddSummaryRow(worksheet, ref row, "Posted By:", completion.PostedBy);
    AddSummaryRow(worksheet, ref row, "Status:", completion.PostSucceeded ? "Success" : "Failed");
    
    row++;
    worksheet.Cells[$"A{row}:B{row}"].Style.Font.Bold = true;
    worksheet.Cells[$"A{row}:B{row}"].Style.Fill.PatternType = ExcelFillStyle.Solid;
    worksheet.Cells[$"A{row}:B{row}"].Style.Fill.BackgroundColor.SetColor(Color.LightGreen);
    
    worksheet.Cells[$"A{row}"].Value = "Processing Statistics";
    row++;
    
    AddSummaryRow(worksheet, ref row, "Items Processed:", completion.ItemsProcessed.ToString());
    AddSummaryRow(worksheet, ref row, "Items Failed:", completion.ItemsInvalid.ToString());
    AddSummaryRow(worksheet, ref row, "Journals Created:", completion.JournalCount.ToString());
    AddSummaryRow(worksheet, ref row, "Total Reversed:", completion.PaymentTotal.ToString("C"));
    
    // Success/failure indicator
    if (completion.PostSucceeded)
    {
        row += 2;
        worksheet.Cells[$"A{row}:F{row}"].Merge = true;
        worksheet.Cells[$"A{row}"].Value = "✓ All payments successfully reversed";
        worksheet.Cells[$"A{row}"].Style.Font.Color.SetColor(Color.Green);
        worksheet.Cells[$"A{row}"].Style.Font.Bold = true;
    }
    else
    {
        row += 2;
        worksheet.Cells[$"A{row}:F{row}"].Merge = true;
        worksheet.Cells[$"A{row}"].Value = $"✗ Posting failed: {completion.ErrorMessage}";
        worksheet.Cells[$"A{row}"].Style.Font.Color.SetColor(Color.Red);
        worksheet.Cells[$"A{row}"].Style.Font.Bold = true;
    }
    
    // Auto-fit columns
    worksheet.Cells[worksheet.Dimension.Address].AutoFitColumns();
}

private async Task AddPaymentsSheet(
    ExcelWorksheet worksheet,
    IEnumerable<PostCompletion_Payment> payments,
    ReportOptions options)
{
    // Define columns for payment data
    var columns = new List<ExcelColumn>
    {
        new ExcelColumn 
        { 
            PropertyName = "Customer", 
            HeaderText = "Customer Code", 
            Order = 1,
            Width = 15 
        },
        new ExcelColumn 
        { 
            PropertyName = "CustomerName", 
            HeaderText = "Customer Name", 
            Order = 2,
            Width = 30 
        },
        new ExcelColumn 
        { 
            PropertyName = "CheckNumber", 
            HeaderText = "Check Number", 
            Order = 3,
            Width = 15 
        },
        new ExcelColumn 
        { 
            PropertyName = "PaymentDate", 
            HeaderText = "Payment Date", 
            Order = 4,
            Format = ExcelColumnFormat.Date,
            Width = 12 
        },
        new ExcelColumn 
        { 
            PropertyName = "OriginalAmount", 
            HeaderText = "Original Amount", 
            Order = 5,
            Format = ExcelColumnFormat.Currency,
            Alignment = ExcelAlignment.Right,
            Width = 15 
        },
        new ExcelColumn 
        { 
            PropertyName = "ReversalAmount", 
            HeaderText = "Reversal Amount", 
            Order = 6,
            Format = ExcelColumnFormat.Currency,
            Alignment = ExcelAlignment.Right,
            Width = 15,
            Transform = v => v != null ? -(decimal)v : 0m
        },
        new ExcelColumn 
        { 
            PropertyName = "Bank", 
            HeaderText = "Bank", 
            Order = 7,
            Width = 10 
        },
        new ExcelColumn 
        { 
            PropertyName = "Journal", 
            HeaderText = "Journal", 
            Order = 8,
            Width = 10 
        },
        new ExcelColumn 
        { 
            PropertyName = "Status", 
            HeaderText = "Status", 
            Order = 9,
            Width = 12 
        }
    };
    
    var exportOptions = new ExcelExportOptions
    {
        WorksheetName = "Payments",
        Columns = columns,
        ApplyFilters = true,
        FreezePanes = true,
        Styling = new ExcelStyleOptions
        {
            HeaderBackgroundColor = Color.DarkBlue,
            HeaderTextColor = Color.White,
            AlternateRowColor = Color.FromArgb(240, 240, 240),
            ShowBorders = true
        }
    };
    
    // Use base export method
    var data = await ExportToExcelAsync(payments, exportOptions);
    
    // Add totals row
    var lastRow = payments.Count() + 2;
    worksheet.Cells[$"A{lastRow}:D{lastRow}"].Merge = true;
    worksheet.Cells[$"A{lastRow}"].Value = "TOTALS:";
    worksheet.Cells[$"A{lastRow}"].Style.Font.Bold = true;
    worksheet.Cells[$"A{lastRow}"].Style.HorizontalAlignment = ExcelHorizontalAlignment.Right;
    
    worksheet.Cells[$"E{lastRow}"].Formula = $"=SUM(E2:E{lastRow-1})";
    worksheet.Cells[$"E{lastRow}"].Style.Numberformat.Format = "$#,##0.00";
    worksheet.Cells[$"E{lastRow}"].Style.Font.Bold = true;
    
    worksheet.Cells[$"F{lastRow}"].Formula = $"=SUM(F2:F{lastRow-1})";
    worksheet.Cells[$"F{lastRow}"].Style.Numberformat.Format = "$#,##0.00";
    worksheet.Cells[$"F{lastRow}"].Style.Font.Bold = true;
}

Export UI Integration

User interface for configuring and executing exports:

<!-- Export Dialog -->
<Window x:Class="MepApps.Dash.Ar.Maint.PaymentReversal.Dialogs.ExportDialog"
        Title="Export to Excel"
        Width="500" Height="600">
    
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        
        <!-- Header -->
        <TextBlock Grid.Row="0" 
                  Text="Configure Excel Export"
                  FontSize="16" 
                  FontWeight="Bold"
                  Margin="0,0,0,10"/>
        
        <!-- Configuration -->
        <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto">
            <StackPanel>
                <!-- Export Type -->
                <GroupBox Header="Export Type" Margin="0,0,0,10">
                    <StackPanel>
                        <RadioButton Content="Current View" 
                                    IsChecked="{Binding ExportCurrentView}"
                                    Margin="5"/>
                        <RadioButton Content="All Data" 
                                    IsChecked="{Binding ExportAllData}"
                                    Margin="5"/>
                        <RadioButton Content="Selected Items Only" 
                                    IsChecked="{Binding ExportSelectedOnly}"
                                    Margin="5"/>
                        <RadioButton Content="Custom Report" 
                                    IsChecked="{Binding ExportCustomReport}"
                                    Margin="5"/>
                    </StackPanel>
                </GroupBox>
                
                <!-- Column Selection -->
                <GroupBox Header="Columns to Export" Margin="0,0,0,10">
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="*"/>
                            <ColumnDefinition Width="Auto"/>
                            <ColumnDefinition Width="*"/>
                        </Grid.ColumnDefinitions>
                        
                        <ListBox Grid.Column="0" 
                                ItemsSource="{Binding AvailableColumns}"
                                SelectionMode="Extended">
                            <ListBox.ItemTemplate>
                                <DataTemplate>
                                    <CheckBox Content="{Binding HeaderText}"
                                             IsChecked="{Binding IsSelected}"/>
                                </DataTemplate>
                            </ListBox.ItemTemplate>
                        </ListBox>
                        
                        <StackPanel Grid.Column="1" 
                                   VerticalAlignment="Center"
                                   Margin="5">
                            <Button Content=">" 
                                   Command="{Binding AddColumnCommand}"
                                   Width="30" Margin="2"/>
                            <Button Content=">>" 
                                   Command="{Binding AddAllColumnsCommand}"
                                   Width="30" Margin="2"/>
                            <Button Content="<" 
                                   Command="{Binding RemoveColumnCommand}"
                                   Width="30" Margin="2"/>
                            <Button Content="<<" 
                                   Command="{Binding RemoveAllColumnsCommand}"
                                   Width="30" Margin="2"/>
                        </StackPanel>
                        
                        <ListBox Grid.Column="2" 
                                ItemsSource="{Binding SelectedColumns}">
                            <ListBox.ItemTemplate>
                                <DataTemplate>
                                    <TextBlock Text="{Binding HeaderText}"/>
                                </DataTemplate>
                            </ListBox.ItemTemplate>
                        </ListBox>
                    </Grid>
                </GroupBox>
                
                <!-- Export Options -->
                <GroupBox Header="Options" Margin="0,0,0,10">
                    <StackPanel>
                        <CheckBox Content="Include Headers" 
                                 IsChecked="{Binding IncludeHeaders}"
                                 Margin="5"/>
                        <CheckBox Content="Auto-fit Columns" 
                                 IsChecked="{Binding AutoFitColumns}"
                                 Margin="5"/>
                        <CheckBox Content="Apply Filters" 
                                 IsChecked="{Binding ApplyFilters}"
                                 Margin="5"/>
                        <CheckBox Content="Freeze Header Row" 
                                 IsChecked="{Binding FreezePanes}"
                                 Margin="5"/>
                        <CheckBox Content="Include Summary Sheet" 
                                 IsChecked="{Binding IncludeSummary}"
                                 Margin="5"/>
                        <CheckBox Content="Open After Export" 
                                 IsChecked="{Binding OpenAfterExport}"
                                 Margin="5"/>
                    </StackPanel>
                </GroupBox>
                
                <!-- File Location -->
                <GroupBox Header="Save Location">
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="*"/>
                            <ColumnDefinition Width="Auto"/>
                        </Grid.ColumnDefinitions>
                        
                        <TextBox Grid.Column="0" 
                                Text="{Binding ExportPath}"
                                IsReadOnly="True"/>
                        <Button Grid.Column="1" 
                               Content="Browse..."
                               Command="{Binding BrowseCommand}"
                               Margin="5,0,0,0"/>
                    </Grid>
                </GroupBox>
            </StackPanel>
        </ScrollViewer>
        
        <!-- Progress -->
        <ProgressBar Grid.Row="2" 
                    Value="{Binding ExportProgress}"
                    Visibility="{Binding IsExporting, 
                               Converter={StaticResource BoolToVisibilityConverter}}"
                    Height="20"
                    Margin="0,10,0,0"/>
        
        <!-- Buttons -->
        <StackPanel Grid.Row="3" 
                   Orientation="Horizontal"
                   HorizontalAlignment="Right"
                   Margin="0,10,0,0">
            <Button Content="Export" 
                   Command="{Binding ExportCommand}"
                   IsDefault="True"
                   Width="80"
                   Margin="0,0,5,0"/>
            <Button Content="Cancel" 
                   IsCancel="True"
                   Width="80"/>
        </StackPanel>
    </Grid>
</Window>

Export ViewModel

Managing export configuration and execution:

// MepApps.Dash.Ar.Maint.PaymentReversal/ViewModels/ExportViewModel.cs
public class ExportViewModel : BaseViewModel
{
    private readonly IExcelExportService _exportService;
    private readonly ILogger<ExportViewModel> _logger;
    
    public async Task ExportAsync()
    {
        try
        {
            IsExporting = true;
            ExportProgress = 0;
            
            // Prepare export options
            var options = new ExcelExportOptions
            {
                WorksheetName = GetWorksheetName(),
                IncludeHeaders = IncludeHeaders,
                AutoFitColumns = AutoFitColumns,
                ApplyFilters = ApplyFilters,
                FreezePanes = FreezePanes,
                Columns = SelectedColumns.ToList(),
                Styling = GetStyleOptions(),
                Metadata = GetMetadata()
            };
            
            // Get data to export
            var data = await GetExportDataAsync();
            ExportProgress = 30;
            
            // Generate Excel file
            byte[] excelData;
            
            if (ExportCustomReport)
            {
                excelData = await _exportService.ExportCompletionReportAsync(
                    _completionData,
                    GetReportOptions());
            }
            else
            {
                excelData = await _exportService.ExportToExcelAsync(
                    data,
                    options);
            }
            
            ExportProgress = 70;
            
            // Save file
            var fileName = GenerateFileName();
            var filePath = await _exportService.SaveExportAsync(
                excelData,
                fileName,
                GetExportLocation());
            
            ExportProgress = 90;
            
            // Open if requested
            if (OpenAfterExport)
            {
                Process.Start(new ProcessStartInfo
                {
                    FileName = filePath,
                    UseShellExecute = true
                });
            }
            
            ExportProgress = 100;
            
            _logger.LogInformation("Export completed: {FileName}", fileName);
            ShowSuccess($"Export saved to: {filePath}");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Export failed");
            ShowError($"Export failed: {ex.Message}");
        }
        finally
        {
            IsExporting = false;
        }
    }
}

Benefits

1. Flexibility: Customizable exports for different needs
2. Professional Output: Formatted, print-ready reports
3. Performance: Efficient handling of large datasets
4. Integration: Easy sharing with other systems
5. Documentation: Permanent record keeping

Related Documentation

• Data Presentation
• Business Logic Services
• Audit History Tracking

Summary

The Excel export integration provides comprehensive, flexible reporting capabilities for the AR Payment Reversal dashboard. Through template-based formatting, dynamic column selection, and multi-worksheet support, users can generate professional reports tailored to various stakeholder requirements while maintaining excellent performance and usability.