inabox/inabox.wpf/DynamicGrid/DynamicGridColumn/DynamicColumnGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using InABox.Core;

namespace InABox.DynamicGrid;

public class DynamicColumnGrid : DynamicGrid<DynamicGridColumn>
{
    public DynamicColumnGrid()
    {
        Columns = new DynamicGridColumns();
    }

    protected override void Init()
    {
        var column = MasterColumns.FirstOrDefault(x => string.Equals(x.ColumnName, nameof(DynamicGridColumn.ColumnName)));
        if(column is not null && column.Editor is DynamicColumnNameEditor edit)
        {
            edit.ColumnNames = () => ProcessColumns().Select(x => x.ColumnName).ToArray();
        }
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        options.RecordCount = true;
        options.MultiSelect = true;
        options.AddRows = true;
        options.EditRows = true;
        options.DeleteRows = true;

        options.ReorderRows = true;
    }

    private Type _type;
    public Type Type
    {
        get => _type;
        set
        {
            _type = value;
            var column = MasterColumns.FirstOrDefault(x => string.Equals(x.ColumnName, nameof(DynamicGridColumn.ColumnName)));
            if(column is not null && column.Editor is DynamicColumnNameEditor edit)
            {
                edit.Type = value;
            }
        }
    }

    public DynamicGridColumns Columns { get; }

    public bool DirectEdit { get; set; }

    protected override void MoveRows(CoreRow[] rows, int index, bool isCopy)
    {
        var targetCol = index < Columns.Count ? Columns[index] : null;
 
        var cols = LoadItems(rows);
        if (isCopy)
        {
            cols = cols.ToArray(x => x.Copy());
        }
        else
        {
            foreach(var col in cols)
            {
                Columns.Remove(col);
            }
        }
        if(targetCol is not null)
        {
            var idx = Columns.IndexOf(targetCol);
            Columns.InsertRange(idx, cols);
        }
        else
        {
            Columns.AddRange(cols);
        }
        Refresh(false, true);
        SelectedRows = cols.Select(x => Columns.IndexOf(x)).Select(x => Data.Rows[x]).ToArray();
    }

    protected override void DoAdd(bool openEditorOnDirectEdit = false)
    {
        if(DynamicGridColumnNameSelectorGrid.SelectColumnName(Type, ProcessColumns().Select(x => x.ColumnName).ToArray(), out var column))
        {
            var item = CreateItem();
            var prop = DatabaseSchema.Property(Type, column);
            item.ColumnName = column;
            if(prop is not null)
            {
                item.Width = prop.Editor.Width;
                item.Alignment = prop.Editor.Alignment;
                item.Format = prop.Editor.Format;
                item.Editor = prop.Editor.CloneEditor();
                item.Caption = prop.Caption;
            }
            SaveItem(item);
            DoChanged();
            Refresh(false, true);
        }
    }

    protected override void DoValidate(DynamicGridColumn[] items, List<string> errors)
    {
        base.DoValidate(items, errors);

        if (items.Any(x => string.IsNullOrWhiteSpace(x.ColumnName)))
            errors.Add("[ColumnName] must not be blank!");
    }

    protected override Dictionary<string, object?> EditorValueChanged(IDynamicEditorForm editor, DynamicGridColumn[] items, string name, object value)
    {
        var changes = base.EditorValueChanged(editor, items, name, value);
        if(name == nameof(DynamicGridColumn.ColumnName) && value is string columnName)
        {
            var prop = DatabaseSchema.Property(Type, columnName);
            if(prop is not null)
            {
                foreach(var item in items)
                {
                    CoreUtils.MonitorChanges(item, () =>
                    {
                        item.Width = prop.Editor.Width;
                        item.Alignment = prop.Editor.Alignment;
                        item.Format = prop.Editor.Format;
                        item.Editor = prop.Editor.CloneEditor();
                        item.Caption = prop.Caption;
                    }, changes);
                }
            }
        }
        return changes;
    }

    private IEnumerable<DynamicGridColumn> ProcessColumns()
    {
        var result = new List<DynamicGridColumn>();
        var cols = new DynamicGridColumns();
        cols.ExtractColumns(Type);
        foreach (var col in cols)
        {
            if (col.Editor == null)
                continue;
            if (col.Editor is NullEditor)
                continue;
            if (col.Editor.Visible != Visible.Hidden)
            {
                result.Add(col);
                continue;
            }

            if (!DirectEdit)
                continue;

            if (col.Editor.Editable.IsEditable() && col.ColumnName.Split('.').Length <= 2)
                result.Add(col);
        }
        result.Sort((a, b) => a.ColumnName.CompareTo(b.ColumnName));

        return result;
    }

    protected override void DefineLookups(ILookupEditorControl sender, DynamicGridColumn[] items, bool async = true)
    {
        if (Type != null && sender.ColumnName.Equals("ColumnName"))
        {
            var results = new CoreTable();
            results.Columns.Add(new CoreColumn { ColumnName = sender.ColumnName, DataType = typeof(string) });
            results.Columns.Add(new CoreColumn { ColumnName = "Display", DataType = typeof(string) });

            var cols = ProcessColumns();
            foreach (var col in cols)
            {
                var row = results.NewRow();
                row[sender.ColumnName] = col.ColumnName;
                row["Display"] = col.ColumnName;
                results.Rows.Add(row);
            }

            sender.LoadLookups(results);
        }
        else
        {
            base.DefineLookups(sender, items, async);
        }
    }

    #region Save / Load

    protected override void Reload(
        Filters<DynamicGridColumn> criteria, Columns<DynamicGridColumn> columns, ref SortOrder<DynamicGridColumn>? sort, 
        CancellationToken token, Action<CoreTable, Exception?> action)
    {
        var result = new CoreTable();
        if (columns == null || columns.Count == 0)
            result.LoadColumns(typeof(DynamicGridColumn));
        else
            result.LoadColumns(columns);
        result.LoadRows(Columns);
        action.Invoke(result, null);
    }

    public override DynamicGridColumn LoadItem(CoreRow row)
    {
        var index = Data.Rows.IndexOf(row);
        return Columns[index];
    }

    public override void SaveItem(DynamicGridColumn item)
    {
        try
        {
            var prop = DatabaseSchema.Property(Type, item.ColumnName);
            item.Editor = prop.Editor;
        }
        catch (Exception e)
        {
            Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
        }

        if (!Columns.Contains(item))
            Columns.Add(item);
    }

    public override void DeleteItems(params CoreRow[] rows)
    {
        foreach (var row in rows.OrderByDescending(x => x.Index))
            Columns.RemoveAt(row.Index);
    }

    #endregion
}