prs/prs.desktop/Grids/EmployeeRosterGrid.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
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 EmployeeRosterDisplayGrid : DynamicGrid<EmployeeRosterItem>
    {
    
        public Employee Employee { get; set; }

        private Button _edit;
        private Button _select;
        private Button _start;
        private Button _delete;
        
        public EmployeeRosterDisplayGrid()
        {
            Options.BeginUpdate()
                .Clear()
                .Add(DynamicGridOption.RecordCount)
                .Add(DynamicGridOption.SelectColumns)
                .EndUpdate();
            
            _edit = AddButton(null, PRSDesktop.Resources.edit.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 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, 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);
        }
        
        private bool EditRoster(Button arg1, CoreRow[] arg2)
        {
            var rosteritems = String.IsNullOrWhiteSpace(Employee?.Roster)
                ? new List<EmployeeRosterItem>()
                : Serialization.Deserialize<List<EmployeeRosterItem>>(Employee.Roster);
            var rostergrid = new DynamicItemsListGrid<EmployeeRosterItem>() { Items = rosteritems };
            rostergrid.Options
                .BeginUpdate()
                .Add(DynamicGridOption.AddRows)
                .Add(DynamicGridOption.DeleteRows)
                .Add(DynamicGridOption.DirectEdit)
                .Add(DynamicGridOption.RecordCount)
                .EndUpdate();
            rostergrid.Refresh(true, true);

            var window = new DynamicContentDialog(rostergrid);
            if (window.ShowDialog() == true)
            {
                Employee.Roster = Serialization.Serialize(rosteritems);
                new Client<Employee>().Save(Employee, "Updated Roster");
                DoChanged();
                return true;
            }

            return false;
        }
        
        private bool SelectRoster(Button arg1, CoreRow[] arg2)
        {
            MultiSelectDialog<EmployeeRoster> dlg = new MultiSelectDialog<EmployeeRoster>(
                null,
                new Columns<EmployeeRoster>(x => x.ID).Add(x => x.Code).Add(x => x.Description).Add(x=>x.Roster),
                false);
            if (dlg.ShowDialog() == true)
            {
                Employee.Roster = dlg.Items().FirstOrDefault()?.Roster;
                new Client<Employee>().Save(Employee, "Updated 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;
            Employee.Roster = "";
            Employee.RosterStart = DateTime.MinValue;
            new Client<Employee>().Save(Employee, "Cleared Roster");
            DoChanged();
            return true;
        }

        protected override EmployeeRosterItem LoadItem(CoreRow row)
        {
            return row.ToObject<EmployeeRosterItem>();
        }

        public override void SaveItem(EmployeeRosterItem item)
        {
        }

        protected override void DeleteItems(params CoreRow[] rows)
        {
        }
        
    }
    
    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;
        }

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

        protected 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}";
            }
        }
    }
    
}