inabox/inabox.wpf/DynamicGrid/Grids/DynamicEnclosedListGrid.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using FastReport.Utils;
using InABox.Configuration;
using InABox.Core;

namespace InABox.DynamicGrid
{
    public interface IDynamicEnclosedListGrid<TOne, TMany> : IDynamicEditorPage
    {
        TOne Entity { get; set; }
        List<TMany> Items { get; }
        void LoadItems(IEnumerable<TMany> items);
    }

    public class DynamicEnclosedListGrid<TOne, TMany> : DynamicGrid<TMany>, IDynamicEditorPage, IDynamicEnclosedListGrid<TOne, TMany>
        where TMany : BaseObject, new() where TOne : Entity, IRemotable, IPersistent, new()
    {
        private readonly List<TMany> MasterList = new();

        private readonly PropertyInfo property;

        public PageType PageType => PageType.Other;

        public bool ReadOnly { get; set; }

        protected DynamicGridCustomColumnsComponent<TMany> ColumnsComponent;

        public DynamicEnclosedListGrid(PropertyInfo prop)
        {
            Items = new List<TMany>();
            property = prop;

            ColumnsComponent = new(this, null);
        }

        protected override void Init()
        {
        }

        protected override void DoReconfigure(DynamicGridOptions options)
        {
            options.RecordCount = true;
            options.SelectColumns = true;
        }

        public DynamicEditorGrid EditorGrid { get; set; }

        public bool Ready { get; set; }

        public string Caption()
        {
            var caption = typeof(TMany).GetCustomAttribute(typeof(Caption));
            if (caption != null)
                return ((Caption)caption).Text;
            var result = new Inflector.Inflector(new CultureInfo("en")).Pluralize(typeof(TMany).Name);
            return result;
        }

    public virtual int Order { get; set; } = int.MinValue;

        public void Load(object item, Func<Type, CoreTable?>? PageDataHandler)
        {
            Entity = (TOne)item;
            MasterList.Clear();
            if (property.GetValue(item) is IList list)
                foreach (var entry in list)
                    MasterList.Add((TMany)entry);
            Items.AddRange(MasterList);
            Refresh(true, true);
            Ready = true;
        }

        public void BeforeSave(object item)
        {
            var list = Activator.CreateInstance(property.PropertyType) as IList;
            foreach (var entry in Items)
                list.Add(entry);
            property.SetValue(item, list);
        }

        public void AfterSave(object item)
        {
        }

        public Size MinimumSize()
        {
            return new Size(400, 400);
        }

        public List<TMany> Items { get; private set; }

        public TOne Entity { get; set; }

        public void LoadItems(IEnumerable<TMany> items)
        {
            Items.Clear();
            if (items != null)
                Items.AddRange(items);
            Refresh(false, true);
        }

        public override DynamicGridColumns GenerateColumns()
        {
            var cols = new DynamicGridColumns();
            cols.AddRange(base.GenerateColumns().Where(x => !x.ColumnName.StartsWith(property.Name + ".")));
            return cols;
        }

        protected override DynamicGridColumns LoadColumns()
        {
            return ColumnsComponent.LoadColumns();
        }

        protected override void SaveColumns(DynamicGridColumns columns)
        {
            ColumnsComponent.SaveColumns(columns);
        }

        protected override void LoadColumnsMenu(ContextMenu menu)
        {
            base.LoadColumnsMenu(menu);
            ColumnsComponent.LoadColumnsMenu(menu);
        }

        public override TMany LoadItem(CoreRow row)
        {
            return Items[row.Index];
        }

        public override void SaveItem(TMany item)
        {
            if (!Items.Contains(item))
                Items.Add(item);

            if (item is ISequenceable && LookupFactory.DefineSort<TMany>() is SortOrder<TMany> sort)
            {
                Items = Items.AsQueryable().SortBy(sort.Expression).ToList();
            }
        }

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

        protected override void Reload(
            Filters<TMany> criteria, Columns<TMany> columns, ref SortOrder<TMany>? sort, 
            CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            var results = new CoreTable();
            results.LoadColumns(typeof(TMany));

            if (sort != null)
            {
                var exp = IQueryableExtensions.ToLambda<TMany>(sort.Expression);
                var sorted = sort.Direction == SortDirection.Ascending
                    ? Items.AsQueryable().OrderBy(exp)
                    : Items.AsQueryable().OrderByDescending(exp);
                foreach (var then in sort.Thens)
                {
                    var thexp = IQueryableExtensions.ToLambda<TMany>(then.Expression);
                    sorted = sort.Direction == SortDirection.Ascending ? sorted.ThenBy(exp) : sorted.ThenByDescending(exp);
                }

                results.LoadRows(sorted);
            }
            else
            {
                results.LoadRows(Items);
            }

            //if (sort != null)
            //    results.LoadRows(Items.AsQueryable().SortBy(sort.Expression));
            //else
            //    results.LoadRows(Items.OrderBy(x => x.Sort));

            action.Invoke(results, null);
        }
    }
}