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 PRSServer;

namespace PRSDesktop
{
    #region Old Stuff
    
        // public class DynamicSpreadsheetColumnGrid : DynamicItemsListGrid<CoreSpreadsheetColumn>
    // {
    //     
    //     public DynamicSpreadsheetColumnGrid() 
    //     {
    //         OnCustomiseEditor += (form, i, column, editor) =>
    //         {
    //             if (editor is ButtonEditor propeditor)
    //                 propeditor.OnClick += (o, e) => PropertiesClick(o, i.FirstOrDefault());
    //         };
    //     }
    //
    //     private void PropertiesClick(object editor, CoreSpreadsheetColumn? item)
    //     {
    //         if (item == null)
    //             return;
    //         var properties = item.GetProperties();
    //         var gridtype = typeof(DynamicItemsListGrid<>).MakeGenericType(properties.GetType());
    //         var grid = Activator.CreateInstance(gridtype) as IDynamicItemsListGrid;
    //         
    //         if (grid == null)
    //             return;
    //
    //         var expeditor = grid.MasterColumns.FirstOrDefault(x => x.Editor is ExpressionEditor)?.Editor as ExpressionEditor;
    //         if (expeditor != null)
    //             expeditor.OnGetVariables += () => Items.Select(x => x.Code);
    //         
    //         grid.Items = new List<CoreSpreadsheetColumnProperties>() { properties };
    //         
    //         if (grid.EditItems(new[] { properties }))
    //             item.Properties = Serialization.Serialize(properties);
    //     }
    // }
    
    // public partial class DynamicSpreadsheetGrid : UserControl
    // {
    //     public DynamicSpreadsheetGrid()
    //     {
    //         InitializeComponent();
    //         _sheet.ActiveGrid.Model.RowsInserted += OnInsertRows;
    //     }
    //     
    //     private CoreSpreadsheet _spreadsheet = null;
    //     public CoreSpreadsheet Spreadsheet
    //     {
    //         get => _spreadsheet;
    //         set
    //         {
    //             _spreadsheet = value;
    //             Load();
    //         }
    //     }
    //
    //
    //     private void SetHeader(CoreSpreadsheetColumn column, int col)
    //     {
    //         var range = _sheet.ActiveSheet.Range[1, col];
    //         _sheet.ActiveGrid.SetCellValue(range, String.IsNullOrWhiteSpace(column.GetProperties().Header) ? column.Code : column.GetProperties().Header);
    //         
    //         range.CellStyle.ColorIndex = ExcelKnownColors.Light_blue;
    //         
    //         range.Borders.LineStyle = ExcelLineStyle.Hair;
    //         range.Borders.Color = ExcelKnownColors.Grey_80_percent;
    //         
    //         range.CellStyle.Locked = true;
    //         
    //         _sheet.FormatOrientation(90);
    //         _sheet.ActiveGrid.InvalidateCell(range.Row, range.Column);
    //     }
    //
    //     private void FormatRow(CoreSpreadsheetColumn column, int row, int col)
    //     {
    //         var range = _sheet.ActiveSheet.Range[row, col];
    //         var properties = column.GetProperties();
    //         if (String.IsNullOrWhiteSpace(properties.Expression))
    //         {
    //             range.CellStyle.ColorIndex = Syncfusion.XlsIO.ExcelKnownColors.Light_yellow;
    //             range.CellStyle.Locked = false;           
    //         }
    //         else
    //         {
    //             _sheet.ActiveGrid.SetCellValue(range, properties.Expression);
    //             range.CellStyle.ColorIndex = Syncfusion.XlsIO.ExcelKnownColors.Grey_25_percent;
    //             range.CellStyle.Locked = true;
    //         }
    //         
    //         range.Borders.LineStyle = ExcelLineStyle.Hair;
    //         range.Borders.Color = ExcelKnownColors.Grey_80_percent;
    //         
    //         _sheet.ActiveGrid.InvalidateCell(range.Row, range.Column);
    //     }
    //     
    //     public void Load()
    //     {
    //
    //         var grid = _sheet.ActiveGrid;
    //         // Set the Header Row
    //         int iColumn = 1;
    //         foreach (var column in _spreadsheet.GetColumns())
    //             SetHeader(column, iColumn++);
    //         _sheet.ActiveSheet.AutofitRow(1);
    //         _sheet.Workbook.ActiveSheet.Range[0, 1].FreezePanes();
    //         _sheet.ActiveGrid.FrozenRows = 1;
    //         _sheet.ActiveGrid.FrozenColumns = 0;
    //         
    //         _sheet.ProtectSheet(_sheet.ActiveSheet, Guid.NewGuid().ToString(), ExcelSheetProtection.InsertingRows | ExcelSheetProtection.DeletingRows);
    //         
    //     }
    //
    //     private void OnInsertRows(object sender, GridRangeInsertedEventArgs e)
    //     {
    //         foreach (var col in _spreadsheet.GetColumns())
    //         {
    //
    //         }
    //     }
    //     
    // }
    
    #endregion 
    
    public abstract class SpreadsheetGrid<TSpreadsheet, TEntity, TEntityLink> : DynamicDataGrid<TSpreadsheet>
        where TEntity : Entity, IPersistent, IRemotable, new()
        where TEntityLink : EntityLink<TEntity>, new()
        where TSpreadsheet : EntitySpreadsheet<TEntity, TEntityLink>, new()
    {

        public Guid ParentID { get; set; }

        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)
        {
            if ((ParentID == Guid.Empty) || (ParentID == CoreUtils.FullGuid))
                criteria.Add(new Filter<TSpreadsheet>(x => x.ID).None());
            else
                criteria.Add(new Filter<TSpreadsheet>(x => x.Parent.ID).IsEqualTo(ParentID));

            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 TSpreadsheet CreateItem()
        {
            var result = base.CreateItem();
            result.Parent.ID = ParentID;
            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 ((ParentID == Guid.Empty) || (ParentID == CoreUtils.FullGuid))
            {
                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);


        }
    }
}