prs/prs.desktop/Components/Spreadsheet/SpreadsheetGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Forms;
using System.Windows.Media.Imaging;
using Comal.Classes;
using FastReport.Dialog;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.DynamicGrid.Spreadsheet;
using InABox.WPF;
using InABox.Wpf;
using PRSServer;

namespace PRSDesktop
{
    public abstract class SpreadsheetGrid<TSpreadsheet, TEntity, TEntityLink> : DynamicDataGrid<TSpreadsheet>, IMasterDetailControl<TEntity,TSpreadsheet>
        where TEntity : Entity, IPersistent, IRemotable, new()
        where TEntityLink : EntityLink<TEntity>, new()
        where TSpreadsheet : EntitySpreadsheet<TEntity, TEntityLink>, new()
    {

        public TEntity? Master { get; set; }

        public Filter<TSpreadsheet> MasterDetailFilter => (Master?.ID ?? Guid.Empty) != Guid.Empty
            ? new Filter<TSpreadsheet>(x => x.Parent.ID).IsEqualTo(Master.ID)
            : new Filter<TSpreadsheet>().None();

        protected override void Init()
        {
            base.Init();

            ActionColumns.Add(new DynamicImageColumn(EditImage, EditSpreadsheet) { Position = DynamicActionColumnPosition.Start });

            HiddenColumns.Add(x => x.Superceded);
            ActionColumns.Add(new DynamicImageColumn(SupercededImage, SupercedeDocument));
        }

        protected override void DoReconfigure(FluentList<DynamicGridOption> options)
        {
            base.DoReconfigure(options);
            options.BeginUpdate().Clear().Add(DynamicGridOption.AddRows)
                .Add(DynamicGridOption.EditRows)
                .Add(DynamicGridOption.DeleteRows)
                .Add(DynamicGridOption.RecordCount)
                .EndUpdate();
        }

        protected override void Reload(Filters<TSpreadsheet> criteria, Columns<TSpreadsheet> columns, ref SortOrder<TSpreadsheet>? sort,
            Action<CoreTable?, Exception?> action)
        {
            criteria.Add(MasterDetailFilter);
            base.Reload(criteria, columns, ref sort, action);
        }

        private BitmapImage SupercededImage(CoreRow? row)
        {
            if (row == null)
                return PRSDesktop.Resources.tick.AsBitmapImage();
            if (row.Get<TSpreadsheet, DateTime>(x => x.Superceded) != DateTime.MinValue)
                return PRSDesktop.Resources.warning.AsBitmapImage();
            return PRSDesktop.Resources.tick.AsBitmapImage();
        }

        private bool SupercedeDocument(CoreRow? row)
        {
            var id = row.Get<TSpreadsheet, Guid>(x => x.ID);
            var superceded = row.Get<TSpreadsheet, DateTime>(x => x.Superceded);
            var spreadsheet = new TSpreadsheet()
            {
                ID = id,
                Superceded = superceded.IsEmpty() ? DateTime.Now : DateTime.MinValue
            };
            new Client<TSpreadsheet>().Save(spreadsheet, "");
            return true;
        }

        private BitmapImage EditImage(CoreRow? arg)
        {
            return PRSDesktop.Resources.pencil.AsBitmapImage();
        }

        private bool EditSpreadsheet(CoreRow? row)
        {
            var spreadsheet = LoadItem(row);
            var window = new SpreadsheetWindow(spreadsheet);
            window.OnSave += SaveSpreadsheet;
            window.ShowDialog();
            Refresh(false, true);
            return false;
        }

        protected override void DoDoubleClick(object sender)
        {
            if (SelectedRows.Any()) 
                EditSpreadsheet(SelectedRows.First());
            else
                base.DoDoubleClick(sender);
        }

        protected override bool CanCreateItems()
        {
            return base.CanCreateItems() && (Master?.ID ?? Guid.Empty) != Guid.Empty;
        }

        protected override TSpreadsheet CreateItem()
        {
            var result = base.CreateItem();
            result.Parent.ID = Master?.ID ?? Guid.Empty;
            result.Parent.Synchronise(Master ?? new TEntity());
            return result;
        }

        private void CreateMenu(ContextMenu parent, string header, Guid id)
        {
            var menu = new MenuItem();
            menu.Header = header;
            menu.Tag = id;
            menu.IsCheckable = false;
            menu.Click += (o, e) => { LoadSpreadsheet(id); };
            parent.Items.Add(menu);
        }

        private void LoadSpreadsheet(Guid id)
        {
            TSpreadsheet spreadsheet = CreateItem();
            if (id != Guid.Empty)
            {
                var template = new Client<SpreadsheetTemplate>().Query(new Filter<SpreadsheetTemplate>(x => x.ID).IsEqualTo(id)).Rows
                    .FirstOrDefault()
                    ?.ToObject<SpreadsheetTemplate>();
                spreadsheet.Code = template.Code;
                spreadsheet.Description = template.Description;
                spreadsheet.Data = template.Data;
            }

            var window = new SpreadsheetWindow(spreadsheet);
            window.OnSave += SaveSpreadsheet;
            window.ShowDialog();
            Refresh(false, true);
        }

        private void SaveSpreadsheet(object sender, SpreadsheetSaveArgs args)
        {
            TSpreadsheet? sheet = args.Spreadsheet as TSpreadsheet;
            if (sheet == null)
                return;
            
            if (args.SaveAs || Guid.Equals(sheet.ID,Guid.Empty))
            {
                sheet.ID = Guid.Empty;
                sheet.CommitChanges();
                sheet.Data = args.Data;
                EditItems(new TSpreadsheet[] { sheet });
            }
            else
            {
                sheet.Data = args.Data;
                new Client<TSpreadsheet>().Save(args.Spreadsheet as TSpreadsheet, "Saved by PRS Spreadsheet");                
            }
        }

        private Dictionary<Guid, String> templates = null;
        
        protected override void DoAdd(bool OpenEditorOnDirectEdit = false)
        {
            if ((Master?.ID ?? Guid.Empty) != Guid.Empty)
            {
                MessageBox.Show($"No {typeof(TEntity).EntityName().Split(".").Last()} selected!");
                return;
            }
            
            var menu = new ContextMenu();
            if (templates == null)
            {
                templates = new Client<SpreadsheetTemplate>().Query(
                    new Filter<SpreadsheetTemplate>(x => x.AppliesTo).IsEqualTo(typeof(TEntity).EntityName().Split(".").Last())
                        .And(x=>x.Active).IsEqualTo(true)
                ).ToDictionary<SpreadsheetTemplate, Guid, String>(
                    x => x.ID,
                    (r) => String.Format("{0}: {1}", r.Get<SpreadsheetTemplate, String>(c => c.Code),
                        r.Get<SpreadsheetTemplate, String>(c => c.Description))
                );
            }


            if (templates.Keys.Any())
            {
                CreateMenu(menu, "Blank Spreadsheet", Guid.Empty);
                menu.Items.Add(new Separator());
                foreach (var key in templates.Keys)
                    CreateMenu(menu, templates[key], key);
                menu.IsOpen = true;
            }
            else
                LoadSpreadsheet(Guid.Empty);


        }
    }
}