prs/prs.desktop/Panels/Employees/Rosters/EmployeeRosterItemDisplayGrid.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using com.sun.crypto.provider;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using Microsoft.Win32;
using Syncfusion.Windows.Shared;

namespace PRSDesktop
{

    public class EmployeeRosterItemDisplayGrid : DynamicDataGrid<EmployeeRosterItem>
    {
        public Employee Employee { get; set; }

        private Button _edit = null!;
        private Button _select = null!;
        private Button _start = null!;
        private Button _delete = null!;

        public EmployeeRosterItemDisplayGrid()
        {
        }

        protected override void Init()
        {
            base.Init();
            _edit = AddButton(null, PRSDesktop.Resources.pencil.AsBitmapImage(), EditRoster);
            _select = AddButton("Select", PRSDesktop.Resources.clock.AsBitmapImage(), SelectRoster);
            _start = AddButton("", PRSDesktop.Resources.assignments.AsBitmapImage(), SelectStart);
            _delete = AddButton(null, PRSDesktop.Resources.delete.AsBitmapImage(), ClearRoster, DynamicGridButtonPosition.Right);
        }

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

        /*protected override DynamicGridColumns LoadColumns()
        {
            var result = new UserConfiguration<DynamicGridColumns>(nameof(EmployeeRosterDisplayGrid)).Load();
            if (!result.Any())
                result = base.LoadColumns();
            return result;
        }

        protected override void SaveColumns(DynamicGridColumns columns) => new UserConfiguration<DynamicGridColumns>(nameof(EmployeeRosterDisplayGrid)).Save(columns);
        
        protected override void Reload(
        	Filters<EmployeeRosterItem> criteria, Columns<EmployeeRosterItem> columns, ref SortOrder<EmployeeRosterItem>? sort,
        	CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            UpdateButtons();
            CoreTable result = new CoreTable();
            result.LoadColumns(typeof(EmployeeRosterItem));
            var rosteritems = String.IsNullOrWhiteSpace(Employee?.Roster)
                ? new List<EmployeeRosterItem>()
                : Serialization.Deserialize<List<EmployeeRosterItem>>(Employee.Roster);
            result.LoadRows(rosteritems);
            action.Invoke(result, null);
        }*/

        protected override void Reload(
        	Filters<EmployeeRosterItem> criteria, Columns<EmployeeRosterItem> columns, ref SortOrder<EmployeeRosterItem>? sort,
        	CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            UpdateButtons();
            if(Employee is null)
            {
                criteria.Add(new Filter<EmployeeRosterItem>().None());
            }
            else
            {
                criteria.Add(new Filter<EmployeeRosterItem>(x => x.Employee.ID).IsEqualTo(Employee.ID));
            }
            base.Reload(criteria, columns, ref sort, token, action);
        }

        private bool EditRoster(Button arg1, CoreRow[] arg2)
        {
            
            var oldItems = LoadItems(Data.Rows.ToArray());
            var items = oldItems.ToList();
            var rostergrid = new DynamicItemsListGrid<EmployeeRosterItem>() { Items = items };
            rostergrid.Reconfigure(options =>
            {
                options.AddRows = true;
                options.DeleteRows = true;
                options.DirectEdit = true;
                options.RecordCount = true;
            });
            rostergrid.Refresh(true, true);

            var window = new DynamicContentDialog(rostergrid);
            if (window.ShowDialog() == true)
            {
                var changes = false;
                var save = new List<EmployeeRosterItem>();
            
                foreach(var item in items)
                {
                    if (oldItems.Contains(item) && item.IsChanged())
                    {
                        save.Add(item);
                    }
                    else
                    {
                        save.Add(item);
                    }
                    changes = true;
                }
                new Client<EmployeeRosterItem>().Save(save, "");
            
                var delete = oldItems.Where(x => !items.Contains(x)).ToList();
                changes = changes || delete.Count > 0;
                new Client<EmployeeRosterItem>().Delete(delete, "");
            
                if (changes && Employee.RosterTemplate.ID != Guid.Empty)
                {
                    Employee.RosterTemplate.ID = Guid.Empty;
                    new Client<Employee>().Save(Employee, "");
                }
            
                DoChanged();
                return true;
            }
            
            return false;
        }
        
        private bool SelectRoster(Button arg1, CoreRow[] arg2)
        {
            MultiSelectDialog<EmployeeRoster> dlg = new MultiSelectDialog<EmployeeRoster>(
                null,
                Columns.None<EmployeeRoster>().Add(x => x.ID).Add(x => x.Code).Add(x => x.Description),
                false);
            if (dlg.ShowDialog() == true && dlg.Items().FirstOrDefault() is EmployeeRoster roster)
            {
                Employee.RosterTemplate.ID = roster.ID;
                Employee.RosterTemplate.Synchronise(roster);

                var templateItems = new Client<EmployeeRosterTemplateItem>()
                    .Load(new Filter<EmployeeRosterTemplateItem>(x => x.Roster.ID).IsEqualTo(roster.ID),
                    new SortOrder<EmployeeRosterTemplateItem>(x => x.Day));

                var items = LoadItems(Data.Rows.ToArray());
                new Client<EmployeeRosterItem>().Delete(items, "Selected roster template");
                new Client<EmployeeRosterItem>().Save(templateItems.Select(x => x.ToEmployeeRosterItem(Employee)), "Selected roster template");

                new Client<Employee>().Save(Employee, "Selected Roster");

                DoChanged();
                return true;

            }
            return false;
        }

        private void UpdateButtons()
        {
            var text = (Employee == null) || (Employee.RosterStart.IsEmpty())
                ? "Select Start Date"
                : $"Start: {Employee.RosterStart:dd MMM yy}";
            UpdateButton(_start, null, text);
            _edit.IsEnabled = Employee?.ID != Guid.Empty;
            _select.IsEnabled = Employee?.ID != Guid.Empty;
            _start.IsEnabled = Employee?.ID != Guid.Empty;
            _delete.IsEnabled = Employee?.ID != Guid.Empty;
        }

        private bool SelectStart(Button arg1, CoreRow[] arg2)
        {
            var date = Employee.RosterStart.IsEmpty() ? DateTime.Today : Employee.RosterStart;
            if (DateEdit.Execute("Select Start Date", ref date))
            {
                Employee.RosterStart = date;
                new Client<Employee>().Save(Employee, "Updated Roster Start Date");
                UpdateButtons();
                DoChanged();
            }
            return false;
        }
        
        private bool ClearRoster(Button arg1, CoreRow[] arg2)
        {
            if (MessageBox.Show("This will clear the selected employee's roster.\n\nAre you sure you wish to continue?", "Confim delete",
                    MessageBoxButton.YesNo) != MessageBoxResult.Yes)
                return false;

            new Client<EmployeeRosterItem>().Delete(LoadItems(Data.Rows.ToArray()), "");

            Employee.RosterStart = DateTime.MinValue;
            Employee.RosterTemplate.ID = Guid.Empty;
            new Client<Employee>().Save(Employee, "Cleared Roster");

            DoChanged();
            return true;
        }
    }
    
    /*public class EmployeeRosterGrid : DynamicItemsListGrid<EmployeeRosterItem>
    {

        public EmployeeRosterGrid()
        {
            AddButton("Import", PRSDesktop.Resources.upload.AsBitmapImage(), ImportItems);
            AddButton("Export", PRSDesktop.Resources.download.AsBitmapImage(), ExportItems);
        }

        private bool ExportItems(Button arg1, CoreRow[] arg2)
        {
            var sfd = new SaveFileDialog();
            sfd.DefaultExt = ".roster";
            sfd.Filter = "Roster Files (*.roster)|*.roster";
            if (sfd.ShowDialog() == true)
            {
                var data = Serialization.Serialize(Items);
                File.WriteAllText(sfd.FileName, data);
            }
            return false;
        }

        private bool ImportItems(Button arg1, CoreRow[] arg2)
        {
            var ofd = new OpenFileDialog();
            ofd.Filter = "Roster Files (*.roster)|*.roster";
            if (ofd.ShowDialog() == true)
            {
                DeleteItems(Data.Rows.ToArray());
                var data = File.ReadAllText(ofd.FileName);
                var items = !String.IsNullOrWhiteSpace(data)
                    ? Serialization.Deserialize<List<EmployeeRosterItem>>(data).ToArray()
                    : new EmployeeRosterItem[] { };
                SaveItems(items);
                return true;
            }
            return false;
        }

        public override EmployeeRosterItem CreateItem()
        {
            var result = base.CreateItem();
            result.Day = Items.Count+1;
            result.Description = $"Day {result.Day}";
            return result;
        }

        public override void DeleteItems(params CoreRow[] rows)
        {
            base.DeleteItems(rows);
            for (int i = 0; i < Items.Count; i++)
            {
                Items[i].Day = i + 1;
                Items[i].Description = $"Day {Items[i].Day}";
            }
        }
    }*/
    
}