prs/prs.desktop/Panels/Requisitions/RequisitionGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Wpf;
using InABox.WPF;
using Color = System.Drawing.Color;

namespace PRSDesktop
{
    
    public class RequisitionSettings : IUserConfigurationSettings
    {
        public DynamicGridSelectedFilterSettings Filters { get; set; } = new();
    }
    internal class RequisitionGrid : DynamicDataGrid<Requisition>
    {
        //public Dictionary<Object, Object> _Employees = new Dictionary<object, object>();
        //public Dictionary<Object, Object> _Jobs = new Dictionary<object, object>();

        private readonly BitmapImage barcode = PRSDesktop.Resources.barcode.AsBitmapImage();
        private RequisitionSettings _settings;
        
        private bool bSplitting;

        private readonly BitmapImage docs = PRSDesktop.Resources.doc_png.AsBitmapImage();
        private readonly BitmapImage forklift = PRSDesktop.Resources.forklift.AsBitmapImage(Color.White);
        private readonly BitmapImage printer = PRSDesktop.Resources.printer.AsBitmapImage();
        private readonly BitmapImage tick = PRSDesktop.Resources.tick.AsBitmapImage(Color.White);
        private readonly BitmapImage truck = PRSDesktop.Resources.truck.AsBitmapImage();

        public RequisitionGrid()
        {
            
            _settings = new UserConfiguration<RequisitionSettings>().Load();
            FilterComponent.SetSettings(_settings.Filters, false);
            FilterComponent.OnFiltersSelected += FilterComponent_OnFilterSelected;
            
            
            ActionColumns.Add(new DynamicImageColumn(DocumentsImage, DocumentsClick) { Position = DynamicActionColumnPosition.Start });
            ActionColumns.Add(new DynamicImageColumn(FilledImage));
            ActionColumns.Add(new DynamicImageColumn(DeliveryImage));
            ActionColumns.Add(new DynamicImageColumn(StockImage));
            //ActionColumns.Add(new DynamicImageColumn() { Action = LabelClick, Image = GetLabelImage });
            //ActionColumns.Add(new DynamicImageColumn() { Action = DeliveryDocketClick, Image = GetPrinterImage });

            HiddenColumns.Add(x => x.JobLink.ID);
            HiddenColumns.Add(x => x.JobLink.JobNumber);
            HiddenColumns.Add(x => x.JobLink.Name);
            HiddenColumns.Add(x => x.JobScope.ID);
            HiddenColumns.Add(x => x.Boxes);
            HiddenColumns.Add(x => x.Filled);
            HiddenColumns.Add(x => x.Title);
            HiddenColumns.Add(x => x.Request);
            HiddenColumns.Add(x => x.Notes);
            HiddenColumns.Add(x => x.Number);
            HiddenColumns.Add(x => x.Employee.ID);
            HiddenColumns.Add(x => x.Employee.Name);
            HiddenColumns.Add(x => x.Due);
            HiddenColumns.Add(x => x.RequestedBy.ID);
            HiddenColumns.Add(x => x.RequestedBy.Name);
            HiddenColumns.Add(x => x.Documents);
            HiddenColumns.Add(x => x.Archived);
            HiddenColumns.Add(x => x.TakenBy.ID);
            HiddenColumns.Add(x => x.TakenBy.Name);
            HiddenColumns.Add(x => x.Delivery.ID);
            HiddenColumns.Add(x => x.Delivery.Number);
            HiddenColumns.Add(x => x.Delivery.Completed);
            HiddenColumns.Add(x => x.StockUpdated);


            //CoreTable employees = new Client<Employee>().Query(
            //	null,
            //	new Columns<Employee>(x => x.ID, x => x.Name),
            //	new SortOrder<Employee>(x => x.Name)
            //);
            //foreach (CoreRow row in employees.Rows)
            //	_Employees[row.Get<Employee, Guid>(x => x.ID)] = row.Get<Employee, String>(x => x.Name);

            //Job[] jobs = new Client<Job>().Load(null, new SortOrder<Job>(x => x.JobNumber));
            //foreach (Job job in jobs)
            //_Jobs[job] = job.ToString();

            AddButton("-", PRSDesktop.Resources.box.AsBitmapImage(Color.White), DelBoxClick);
            AddButton("+", PRSDesktop.Resources.box.AsBitmapImage(Color.White), AddBoxClick);

            AddButton("Split", PRSDesktop.Resources.split.AsBitmapImage(), SplitRequiClick);

            //AddButton("Labels", PRSDesktop.Resources.barcode.AsBitmapImage(System.Drawing.Color.White), LabelClick);
            //AddButton("Del Dkt", PRSDesktop.Resources.printer.AsBitmapImage(System.Drawing.Color.White), DeliveryDocketClick);

            //AddButton("Complete", PRSDesktop.Resources.tick.AsBitmapImage(System.Drawing.Color.White), FilledClick);

            OnCustomiseEditor += CustomiseEditor;
        }
        
        private void FilterComponent_OnFilterSelected(DynamicGridSelectedFilterSettings settings)
        {
            _settings.Filters = settings;
            new UserConfiguration<RequisitionSettings>().Save(_settings);
        }
        protected override void DoReconfigure(DynamicGridOptions options)
        {
            base.DoReconfigure(options);

            options.SelectColumns = true;
            options.AddRows = true;
            options.EditRows = true;
            options.FilterRows = true;
            if (Security.IsAllowed<CanDeleteStoresRequisitions>())
                options.DeleteRows = true;
        }

        public CoreTable Requisitions { get; private set; }

        private void CustomiseEditor(IDynamicEditorForm sender, Requisition[]? items, DynamicGridColumn column, BaseEditor editor)
        {
            if (column.ColumnName.Equals("Notes"))
            {
                if (editor is NotesEditor notes)
                    notes.AlwaysEnabled = bSplitting;
            }

            else if (column.ColumnName.Equals("Filled"))
            {
                editor.Editable = Security.IsAllowed<CanSkipRequisitionPhotos>() || (items != null && items.Any() && items.First().Documents > 0)
                    ? Editable.Enabled
                    : Editable.Hidden;
            }

            else if (column.ColumnName.Equals("TakenBy.ID"))
            {
                editor.Editable = items != null && items.Any() && !items.First().Filled.IsEmpty() ? Editable.Enabled : Editable.Disabled;
            }
        }

        protected override Dictionary<string, object?> EditorValueChanged(IDynamicEditorForm editor, Requisition[] items, string name, object value)
        {
            var result = base.EditorValueChanged(editor, items, name, value);

            if (name.Equals("TakenBy.ID") && (value == null || Equals(value, Guid.Empty)))
                editor.SetEditorValue("Archived", DateTime.MinValue);
            else if (name.Equals("JobLink.ID"))
            {
                // false here because a job has a defaultscope
                // and we need to load the lookups before we set the default value
                var scope = editor.FindEditor("JobScope.ID") as ILookupEditorControl;
                if (scope != null)
                    DefineLookups(scope,items,false); 
            }
            return result;
        }

        private bool DocumentsClick(CoreRow? arg)
        {
            if (arg == null)
                return false;

            var docs = new List<IEntityDocument>();
            using (new WaitCursor())
            {
                var deliveryid = arg.Get<Requisition, Guid>(x => x.ID);
                var table = new Client<RequisitionDocument>().Query(
                    new Filter<RequisitionDocument>(x => x.EntityLink.ID).IsEqualTo(deliveryid)
                );
                foreach (var row in table.Rows)
                    docs.Add(row.ToObject<RequisitionDocument>());
            }

            if (docs.Any())
            {
                var editor = new DocumentEditor(docs.ToArray());
                //editor.PrintAllowed = Security.IsAllowed<CanPrintFactoryFloorDrawings>();
                editor.SaveAllowed = Security.IsAllowed<CanSaveFactoryFloorDrawings>();
                editor.ShowDialog();
            }
            else
            {
                MessageBox.Show("No Documents Available!");
            }

            return false;
        }

        private BitmapImage? DocumentsImage(CoreRow? arg)
        {
            if (arg is null)
                return docs;
            return arg.Get<Requisition, int>(x => x.Documents) > 0 ? docs : null;
        }

        private bool SplitRequiClick(Button sender, CoreRow[] rows)
        {

            var result = false;
            
            if ((rows?.Length ?? 0) != 1)
            {
                MessageBox.Show("Please select a single Picking List to Split!");
                return result;
            }
            
            var confirm = MessageWindow.ShowYesNoCancel("Do you wish to move unpicked items to the new picking list?","Confirm");
            if (confirm == MessageWindowResult.Cancel)
                return false;
            
            bSplitting = true;
            if (SplitPickingList(rows![0], confirm == MessageWindowResult.Yes, (r) => EditItems(new Requisition[] { r }) )) 
                result = true;

            bSplitting = false;
            return result;
        }

        public bool SplitPickingList(CoreRow row, bool moveunpickeditems, Func<Requisition,bool> edit, IProgress<string>? progress = null)
        {

            var oldrequi = row.ToObject<Requisition>();
            var newrequi = row.ToObject<Requisition>();
            newrequi.ID = Guid.Empty;
            newrequi.Number = 0;
            newrequi.CommitChanges();
            
            newrequi.Filled = DateTime.MinValue;
            
            List<RequisitionItem> unpicked = moveunpickeditems
                ? Client.Query<RequisitionItem>(
                    new Filter<RequisitionItem>(x => x.RequisitionLink.ID).IsEqualTo(oldrequi.ID)
                        .And(x => x.ActualQuantity).IsEqualTo(0.0),
                    Columns.Required<RequisitionItem>()
                ).Rows.Select(x => x.ToObject<RequisitionItem>()).ToList()
                : new List<RequisitionItem>();
            
            newrequi.Notes = new[]
            {
                string.Format("Items unavailable on Picking List #{0}:\n{1}{2}", 
                    oldrequi,
                    string.Join("\n",unpicked.Select(x=>$"{x.Quantity} x {x.Description}")),
                    string.Join("\n\n==============================", oldrequi.Notes)
                )
            };
            
            if (edit(newrequi))
            {
                
                progress?.Report("Creating new Picking List");
                bSplitting = false;
                new Client<Requisition>().Save(newrequi, "Created by Splitting Picking List #" + oldrequi.Number);
                
                if (unpicked.Any())
                {
                    progress?.Report("Moving unpicked items");
                    foreach (var item in unpicked)
                        item.RequisitionLink.ID = newrequi.ID;
                    Client.Save(unpicked,$"Moved from {oldrequi.Number} to {newrequi.Number}");
                }
                progress?.Report("Updating Original Picking List");
                var _notes = oldrequi.Notes.ToList();
                _notes.Insert(0,
                    $"Created secondary Picking List #{newrequi.Number} for further action:\n\nOriginal Picking List Notes:\n");
                oldrequi.Notes = _notes.ToArray();
                new Client<Requisition>().Save(oldrequi, "Split Picking List to #" + newrequi);
                
                return true;
            }

            return false;
        }

        private bool AddBoxClick(Button btn, CoreRow[] rows)
        {
            if (rows.Length != 1)
            {
                MessageBox.Show("Please select one row to process!");
                return false;
            }

            var row = rows.First();
            var id = row.Get<Requisition, Guid>(x => x.ID);
            var req = new Client<Requisition>().Load(
                new Filter<Requisition>(x => x.ID).IsEqualTo(id)
            ).FirstOrDefault();
            if (req != null)
            {
                req.Boxes++;
                new Client<Requisition>().Save(req, string.Format("Set Number of Boxes to {0}", req.Boxes));
                //OnRequisitionBoxesChanged?.Invoke(req.ID, req.Boxes);
                return true;
            }

            MessageBox.Show("Cannot locate Requisition");

            return true;
        }

        private bool DelBoxClick(Button btn, CoreRow[] rows)
        {
            if (rows.Length != 1)
            {
                MessageBox.Show("Please select one row to process!");
                return false;
            }

            var row = rows.First();
            var id = row.Get<Requisition, Guid>(x => x.ID);
            var req = new Client<Requisition>().Load(
                new Filter<Requisition>(x => x.ID).IsEqualTo(id)
            ).FirstOrDefault();
            if (req != null)
            {
                if (req.Boxes > 0)
                {
                    req.Boxes--;
                    new Client<Requisition>().Save(req, string.Format("Set Number of Boxes to {0}", req.Boxes));
                    //OnRequisitionBoxesChanged?.Invoke(req.ID, req.Boxes);
                }

                return true;
            }

            MessageBox.Show("Cannot Locate Requisition!");

            return true;
        }

        public override Requisition CreateItem()
        {
            var requi = base.CreateItem();

            var role = new Client<Role>().Load(new Filter<Role>(x => x.Code).IsEqualTo("STORES")).FirstOrDefault();
            if (role != null)
            {
                var emprole = new Client<EmployeeRole>().Load(new Filter<EmployeeRole>(x => x.RoleLink.ID).IsEqualTo(role.ID)).FirstOrDefault();
                if (emprole != null)
                    requi.Employee.ID = emprole.EmployeeLink.ID;
            }

            return requi;
        }

        private BitmapImage? GetBitmapImage(CoreRow? row, BitmapImage image)
        {
            if (row == null)
                return image;
            var filled = row.Get<Requisition, DateTime>(x => x.Filled);
            return filled.IsEmpty() ? null : image;
        }

        private BitmapImage? GetLabelImage(CoreRow row)
        {
            return GetBitmapImage(row, barcode);
        }

        private BitmapImage? GetPrinterImage(CoreRow row)
        {
            return GetBitmapImage(row, printer);
        }

        private BitmapImage? FilledImage(CoreRow? row)
        {
            if (row == null)
                return tick;
            var filled = row.Get<Requisition, DateTime>(x => x.Filled);

            return filled.IsEmpty() ? null : tick;
        }

        private BitmapImage? StockImage(CoreRow? row)
        {
            if (row == null)
                return forklift;

            var stockupdated = row.Get<Requisition, DateTime>(x => x.StockUpdated);

            return stockupdated.IsEmpty() ? null : forklift;
        }

        private BitmapImage? DeliveryImage(CoreRow? row)
        {
            if (row == null)
                return truck;

            var archived = row.Get<Requisition, DateTime>(x => x.Archived);

            return archived.IsEmpty() ? null : truck;
        }

        private void SendNotifications(CoreRow row)
        {
            var updates = new List<Notification>();
            var roles = new Client<EmployeeRole>().Query(new Filter<EmployeeRole>(x => x.RoleLink.Code).IsEqualTo("DELIVERIES"));
            foreach (var role in roles.Rows)
            {
                var notification = new Notification
                {
                    Title = string.Format("Requi #{0} is ready", row.Get<Requisition, int>(x => x.Number)),
                    Description = "The requisition has been packed and labelled, and is ready to be assigned to a Delivery"
                };
                notification.Sender.ID = row.Get<Requisition, Guid>(x => x.Employee.ID);
                notification.Employee.ID = role.Get<EmployeeRole, Guid>(x => x.EmployeeLink.ID);
                notification.Job.ID = row.Get<Requisition, Guid>(x => x.JobLink.ID);
                updates.Add(notification);
            }

            new Client<Notification>().Save(updates, "Sent Notification");
        }

        protected override void Reload(
        	Filters<Requisition> criteria, Columns<Requisition> columns, ref SortOrder<Requisition>? sort,
        	CancellationToken token, Action<CoreTable?, Exception?> action)
        {
            sort = new SortOrder<Requisition>(x => x.Number, SortDirection.Descending);

            base.Reload(criteria, columns, ref sort, token, action);
        }
    }
}