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()
    {
        DynamicGridColumns uvc = null;
        DynamicGridColumns udc = null;
        DynamicGridColumns gvc = null;
        DynamicGridColumns gdc = null;
        var tasks = new Task[]
        {
            Task.Run(() => uvc = new UserConfiguration<DynamicGridColumns>(GetTag(false)).Load()),
            Task.Run(() => udc = new UserConfiguration<DynamicGridColumns>(GetTag(true)).Load()),
            Task.Run(() => gvc = new GlobalConfiguration<DynamicGridColumns>(GetTag(false)).Load()),
            Task.Run(() => gdc = new GlobalConfiguration<DynamicGridColumns>(GetTag(true)).Load())
            
        };
        Task.WaitAll(tasks);
        var columns = Grid.IsDirectEditMode()
            ? udc?.Any() == true 
                ? udc 
                : gdc?.Any() == true
                    ? gdc
                    : uvc?.Any() == true
                        ? uvc
                        : gvc ?? new DynamicGridColumns()
            : uvc?.Any() == true
                ? uvc
                : gvc ?? new DynamicGridColumns();
        
        // 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(Grid.IsDirectEditMode());
        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(bool directedit)
    {
        var tag = Tag ?? typeof(T).Name;
        if (directedit)
            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(Grid.IsDirectEditMode());
        new GlobalConfiguration<DynamicGridColumns>(tag).Save(Grid.VisibleColumns);
        new UserConfiguration<DynamicGridColumns>(tag).Delete();
        Grid.Refresh(true, true);
    }
}