Ai/TrafagSalesExporter/Components/Pages/Transformations.razor

@page "/transformations"
@using Microsoft.EntityFrameworkCore
@using System.Reflection
@using TrafagSalesExporter.Data
@using TrafagSalesExporter.Models
@using TrafagSalesExporter.Services
@inject IDbContextFactory<AppDbContext> DbFactory
@inject ITransformationCatalog TransformationCatalog
@inject ISnackbar Snackbar

<PageTitle>Transformationen</PageTitle>

<MudText Typo="Typo.h4" Class="mb-4">Transformer Ansicht</MudText>
<MudText Typo="Typo.body1" Class="mb-4">Definiere pro Quellsystem einfache Feldregeln und komplexe record-basierte Strategien.</MudText>

<MudPaper Class="pa-4" Elevation="1">
    <MudAlert Severity="Severity.Info" Dense="true" Variant="Variant.Outlined" Class="mb-3">
        `Value`-Regeln arbeiten feldweise. `Record`-Regeln rufen eine registrierte C#-Strategie auf und koennen mehrere Felder eines Datensatzes verwenden.
    </MudAlert>

    <MudStack Row="true" Spacing="2" Class="mb-3">
        <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.Add" OnClick="AddRule">
            Regel hinzufuegen
        </MudButton>
        <MudButton Variant="Variant.Outlined" Color="Color.Secondary" StartIcon="@Icons.Material.Filled.Save" OnClick="SaveAllAsync">
            Alle speichern
        </MudButton>
    </MudStack>

    <MudTable Items="_rules" Dense Hover Striped>
        <HeaderContent>
            <MudTh>Aktiv</MudTh>
            <MudTh>System</MudTh>
            <MudTh>Scope</MudTh>
            <MudTh>Source</MudTh>
            <MudTh>Target</MudTh>
            <MudTh>Typ</MudTh>
            <MudTh>Argument</MudTh>
            <MudTh>Sort</MudTh>
            <MudTh>Aktionen</MudTh>
        </HeaderContent>
        <RowTemplate>
            <MudTd><MudCheckBox @bind-Value="context.IsActive" /></MudTd>
            <MudTd>
                <MudSelect T="string" Value="@context.SourceSystem" ValueChanged="@(v => context.SourceSystem = v)" Dense>
                    @foreach (var system in _systems)
                    {
                        <MudSelectItem Value="@system">@system</MudSelectItem>
                    }
                </MudSelect>
            </MudTd>
            <MudTd>
                <MudSelect T="string" Value="@context.RuleScope" ValueChanged="@(v => ChangeRuleScope(context, v))" Dense>
                    @foreach (var scope in _ruleScopes)
                    {
                        <MudSelectItem Value="@scope">@scope</MudSelectItem>
                    }
                </MudSelect>
            </MudTd>
            <MudTd>
                <MudSelect T="string" Value="@context.SourceField" ValueChanged="@(v => context.SourceField = v)" Dense Disabled="@IsRecordScope(context)">
                    @foreach (var field in _recordFields)
                    {
                        <MudSelectItem Value="@field">@field</MudSelectItem>
                    }
                </MudSelect>
            </MudTd>
            <MudTd>
                <MudSelect T="string" Value="@context.TargetField" ValueChanged="@(v => context.TargetField = v)" Dense>
                    @foreach (var field in _recordFields)
                    {
                        <MudSelectItem Value="@field">@field</MudSelectItem>
                    }
                </MudSelect>
            </MudTd>
            <MudTd>
                <MudSelect T="string" Value="@context.TransformationType" ValueChanged="@(v => context.TransformationType = v)" Dense>
                    @foreach (var type in GetTypesForScope(context.RuleScope))
                    {
                        <MudSelectItem Value="@type.Key">@type.Key</MudSelectItem>
                    }
                </MudSelect>
            </MudTd>
            <MudTd>
                <MudTextField T="string" Value="@context.Argument" ValueChanged="@(v => context.Argument = v)"
                              HelperText="@GetArgumentHelperText(context)" />
            </MudTd>
            <MudTd>
                <MudNumericField T="int" Value="@context.SortOrder" ValueChanged="@(v => context.SortOrder = v)" Dense />
            </MudTd>
            <MudTd>
                <MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small"
                               OnClick="() => RemoveRule(context)" />
            </MudTd>
        </RowTemplate>
    </MudTable>
</MudPaper>

@code {
    private readonly string[] _systems = ["SAP", "BI1", "SAGE", "MANUAL_EXCEL"];
    private readonly string[] _ruleScopes = ["Value", "Record"];
    private readonly string[] _recordFields = typeof(SalesRecord)
        .GetProperties(BindingFlags.Public | BindingFlags.Instance)
        .Select(p => p.Name)
        .OrderBy(n => n)
        .ToArray();

    private List<FieldTransformationRule> _rules = new();
    private IReadOnlyList<TransformationCatalogItem> _catalogItems = [];

    protected override async Task OnInitializedAsync()
    {
        _catalogItems = TransformationCatalog.GetAll();
        await LoadAsync();
    }

    private async Task LoadAsync()
    {
        using var db = await DbFactory.CreateDbContextAsync();
        _rules = await db.FieldTransformationRules.OrderBy(r => r.SortOrder).ThenBy(r => r.Id).ToListAsync();

        foreach (var rule in _rules)
        {
            rule.RuleScope = string.IsNullOrWhiteSpace(rule.RuleScope) ? "Value" : rule.RuleScope;
            if (!GetTypesForScope(rule.RuleScope).Any(x => string.Equals(x.Key, rule.TransformationType, StringComparison.OrdinalIgnoreCase)))
            {
                rule.TransformationType = GetTypesForScope(rule.RuleScope).FirstOrDefault()?.Key ?? "Copy";
            }
        }
    }

    private void AddRule()
    {
        var nextSort = _rules.Count == 0 ? 10 : _rules.Max(r => r.SortOrder) + 10;
        _rules.Add(new FieldTransformationRule
        {
            SourceSystem = "SAP",
            RuleScope = "Value",
            SourceField = nameof(SalesRecord.Material),
            TargetField = nameof(SalesRecord.Material),
            TransformationType = "Copy",
            SortOrder = nextSort,
            IsActive = true
        });
    }

    private void RemoveRule(FieldTransformationRule rule)
    {
        _rules.Remove(rule);
    }

    private async Task SaveAllAsync()
    {
        using var db = await DbFactory.CreateDbContextAsync();
        db.FieldTransformationRules.RemoveRange(db.FieldTransformationRules);
        await db.SaveChangesAsync();

        db.FieldTransformationRules.AddRange(_rules);
        await db.SaveChangesAsync();

        Snackbar.Add("Transformationsregeln gespeichert.", Severity.Success);
        await LoadAsync();
    }

    private IReadOnlyList<TransformationCatalogItem> GetTypesForScope(string? ruleScope)
    {
        var scope = string.IsNullOrWhiteSpace(ruleScope) ? "Value" : ruleScope;
        return TransformationCatalog.GetByScope(scope);
    }

    private static bool IsRecordScope(FieldTransformationRule rule)
        => string.Equals(rule.RuleScope, "Record", StringComparison.OrdinalIgnoreCase);

    private void ChangeRuleScope(FieldTransformationRule rule, string scope)
    {
        rule.RuleScope = scope;
        var firstType = GetTypesForScope(scope).FirstOrDefault()?.Key;
        if (!string.IsNullOrWhiteSpace(firstType))
            rule.TransformationType = firstType;

        if (IsRecordScope(rule))
            rule.SourceField = string.Empty;
        else if (string.IsNullOrWhiteSpace(rule.SourceField))
            rule.SourceField = nameof(SalesRecord.Material);
    }

    private string GetArgumentHelperText(FieldTransformationRule rule)
    {
        var item = _catalogItems.FirstOrDefault(x =>
            string.Equals(x.RuleScope, rule.RuleScope, StringComparison.OrdinalIgnoreCase) &&
            string.Equals(x.Key, rule.TransformationType, StringComparison.OrdinalIgnoreCase));

        return item?.Description ?? "Optionales Argument.";
    }
}