inabox/inabox.wpf/DynamicGrid/DynamicGridCustomColumnsComponent.cs

using InABox.Configuration;
using InABox.Core;
using InABox.WPF;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;

namespace InABox.DynamicGrid;

/// <summary>
/// A component which loads a custom set of columns from the database.
/// </summary>
public class DynamicGridCustomColumnsComponent<T>
    where T : BaseObject, new()
{
    private readonly DynamicGrid<T> Grid;

    public Func<DynamicGridColumns> DefaultColumns { get; set; }

    public string? Tag { get; set; }

    public DynamicGridCustomColumnsComponent(DynamicGrid<T> grid, string? tag, Func<DynamicGridColumns> defaultColumns)
    {
        Grid = grid;
        Tag = tag;
        DefaultColumns = defaultColumns;
    }

    public DynamicGridColumns LoadColumns()
    {
        var tag = GetTag();

        var user = Task.Run(() => new UserConfiguration<DynamicGridColumns>(tag).Load());
        user.Wait();

        var global = Task.Run(() => new GlobalConfiguration<DynamicGridColumns>(tag).Load());
        global.Wait();
        //Task.WaitAll(user, global);
        var columns = user.Result.Any() ? user.Result : global.Result;

        //if (!columns.Any())
        //    GenerateColumns(columns); //override this to provide specific columns on startup

        var removes = columns.Where(x => x is null || string.IsNullOrWhiteSpace(x.ColumnName) || DatabaseSchema.Property(typeof(T), x.ColumnName) == null || GetColumnEditor(x) is NullEditor)
           .ToArray();
        foreach (var remove in removes)
            columns.Remove(remove);
        if (columns.Count == 0)
            columns.AddRange(DefaultColumns());

        foreach (var column in columns)
            try
            {
                var prop = DatabaseSchema.Property(typeof(T), column.ColumnName);
                if (prop != null)
                {
                    column.Editor = prop.Editor;
                }
                else
                {
                    var type = CoreUtils.GetProperty(typeof(T), column.ColumnName);
                    column.Editor = type.GetEditor() ?? new NullEditor();
                }
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
            }

        columns.RemoveAll(x => DatabaseSchema.Property(typeof(T), x.ColumnName) == null || GetColumnEditor(x) is NullEditor);
        return columns;
    }

    public void SaveColumns(DynamicGridColumns columns)
    {
        var tag = GetTag();
        new UserConfiguration<DynamicGridColumns>(tag).Save(columns);
    }

    public void LoadColumnsMenu(ContextMenu menu)
    {
        menu.AddSeparatorIfNeeded();
        var ResetColumns = new MenuItem { Header = "Reset Columns to Default" };
        ResetColumns.Click += ResetColumnsClick;
        menu.Items.Add(ResetColumns);
        if (Security.IsAllowed<CanSetDefaultColumns>())
        {
            menu.Items.Add(new Separator());
            var UpdateDefaultColumns = new MenuItem { Header = "Mark Columns as Default" };
            UpdateDefaultColumns.Click += UpdateDefaultColumnsClick;
            menu.Items.Add(UpdateDefaultColumns);
        }
    }

    private string GetTag()
    {
        var tag = Tag ?? typeof(T).Name;
        if (Grid.IsDirectEditMode())
        {
            tag += ":DirectEdit";
        }
        return tag;
    }

    private static BaseEditor GetColumnEditor(DynamicGridColumn column)
    {
        try
        {
            var prop = DatabaseSchema.Property(typeof(T), column.ColumnName);
            if (prop != null) return prop.Editor;

            var type = CoreUtils.GetProperty(typeof(T), column.ColumnName);
            return type.GetEditor() ?? new NullEditor();
        }
        catch (Exception e)
        {
            Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
        }

        return new NullEditor();
    }

    private void ResetColumnsClick(object sender, RoutedEventArgs e)
    {
        Grid.VisibleColumns.Clear();
        SaveColumns(Grid.VisibleColumns);
        Grid.Refresh(true, true);
    }

    private void UpdateDefaultColumnsClick(object sender, RoutedEventArgs e)
    {
        var tag = GetTag();
        new GlobalConfiguration<DynamicGridColumns>(tag).Save(Grid.VisibleColumns);
        new UserConfiguration<DynamicGridColumns>(tag).Delete();
        Grid.Refresh(true, true);
    }
}