prs/prs.desktop/Panels/Requisitions/RequisitionItemGrid.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.Wpf;
using InABox.WPF;
using Microsoft.Office.Interop.Outlook;
using Syncfusion.Windows.Tools.Controls;
using Exception = System.Exception;

namespace PRSDesktop
{
    public class RequisitionItemGrid : DynamicDataGrid<RequisitionItem>
    {
        //public int Boxes { get; set; }

        private static readonly BitmapImage tick = PRSDesktop.Resources.tick.AsBitmapImage();

        public RequisitionItemGrid()
        {
            HiddenColumns.Add(x => x.Code);
            HiddenColumns.Add(x => x.BarCode);
            HiddenColumns.Add(x => x.RequisitionLink.ID);
            HiddenColumns.Add(x => x.RequisitionLink.JobLink.ID);
            HiddenColumns.Add(x => x.RequisitionLink.JobScope.ID);
            HiddenColumns.Add(x => x.RequisitionLink.Filled);
            HiddenColumns.Add(x => x.RequisitionLink.Archived);
            HiddenColumns.Add(x => x.Product.ID);
            HiddenColumns.Add(x => x.Product.Deleted);
            HiddenColumns.Add(x => x.Product.DefaultInstance.Style.ID);

            foreach(var column in new Columns<RequisitionItem>()
                .AddDimensionsColumns(x => x.Product.DefaultInstance.Dimensions, Dimensions.ColumnsType.Data)
                .GetColumns())
            {
                HiddenColumns.Add(column);
            }

            //HiddenColumns.Add(x => x.Product.Units.ID);
            HiddenColumns.Add(x => x.Product.NonStock);
            HiddenColumns.Add(x => x.Location.ID);
            HiddenColumns.Add(x => x.Location.Code);
            HiddenColumns.Add(x => x.Location.Description);
            HiddenColumns.Add(x => x.Location.Deleted);
            HiddenColumns.Add(x => x.Style.ID);
            HiddenColumns.Add(x => x.Style.Code);
            HiddenColumns.Add(x => x.Picked);
            
            HiddenColumns.Add(x => x.Image.ID);
            HiddenColumns.Add(x => x.Image.FileName);
            ActionColumns.Add(new DynamicImageManagerColumn<RequisitionItem>(this, x => x.Image, true) { Position = DynamicActionColumnPosition.Start });
            
            ActionColumns.Add(new DynamicImageColumn(Pick_Image, Pick_Click)
            {
                ToolTip = Pick_ToolTip
            });
            ActionColumns.Add(new DynamicMenuColumn(SelectHolding,
                (row) => (row.Get<RequisitionItem, Guid>(c => c.Product.ID) == Guid.Empty) || row.Get<RequisitionItem, bool>(c => c.Product.NonStock) == true
                    ? DynamicMenuStatus.Hidden
                    : DynamicMenuStatus.Enabled)
            );
        }

        private FrameworkElement? Pick_ToolTip(DynamicActionColumn column, CoreRow? row)
        {
            string content;
            if (row is null)
            {
                content = "Has this item been picked?";
            }
            else
            {
                if(!row.Get<RequisitionItem, DateTime>(x => x.Picked).IsEmpty())
                {
                    content = "This item has been picked";
                }
                else
                {
                    content = "This item has not been picked";
                }
            }
            return column.TextToolTip(content);
        }

        private BitmapImage? Pick_Image(CoreRow? row)
        {
            return row is null
                ? tick
                : (row.Get<RequisitionItem, DateTime>(x => x.Picked).IsEmpty()
                    ? null
                    : tick);
        }

        private bool Pick_Click(CoreRow? row)
        {
            if(row is null)
            {
                return false;
            }

            var reqItem = row.ToObject<RequisitionItem>();
            return ProcessItems(reqItem.Picked.IsEmpty() ? DateTime.Now : DateTime.MinValue, CoreUtils.One(reqItem));
        }

        private static bool ProcessItems(DateTime picked, IEnumerable<RequisitionItem> items)
        {
            var list = new List<RequisitionItem>();
            foreach (var item in items)
            {
                item.Picked = picked;

                if (!picked.IsEmpty())
                {
                    var quantity = item.Quantity;
                    if (!DoubleEdit.Execute("Enter actual quantity picked:", 0, double.MaxValue, ref quantity))
                    {
                        continue;
                    }

                    item.ActualQuantity = quantity;
                }
                else
                    item.ActualQuantity = 0;

                list.Add(item);
            }

            if(list.Count > 0)
            {
                string audittrail;
                if (picked == DateTime.MinValue)
                    audittrail = "Item unpicked";
                else
                    audittrail = "Item picked " + picked.ToString("dd MMM yy");
                Client.Save(list, audittrail);
                return true;
            }
            else
            {
                return false;
            }
        }

        protected override void DoReconfigure(FluentList<DynamicGridOption> options)
        {
            base.DoReconfigure(options);
            options.BeginUpdate()
                .Add(DynamicGridOption.RecordCount)
                .Add(DynamicGridOption.SelectColumns)
                .Add(DynamicGridOption.AddRows)
                .Add(DynamicGridOption.EditRows)
                .Add(DynamicGridOption.DeleteRows)
                .Add(DynamicGridOption.FilterRows)
                .Add(DynamicGridOption.MultiSelect)
                .Add(DynamicGridOption.DirectEdit)
                .Add(DynamicGridOption.DragTarget)
                .EndUpdate();
        }

        private bool CanAddItems() =>
            Requisition is not null && Requisition.ID != Guid.Empty && Requisition.Filled.IsEmpty() && Security.CanEdit<Requisition>() && Security.CanEdit<RequisitionItem>();

        protected override void HandleDragOver(object sender, DragEventArgs e)
        {
            base.HandleDragOver(sender, e);

            if (e.Data.GetDataPresent(typeof(Product)))
            {
                if (e.Data.GetData(typeof(Product)) is Product product)
                {
                    if (!CanAddItems())
                    {
                        e.Effects = DragDropEffects.None;
                    }
                }
            }
        }

        protected override void HandleDragDrop(object sender, DragEventArgs e)
        {
            base.HandleDragDrop(sender, e);

            if (e.Data.GetDataPresent(typeof(Product)))
            {
                if(e.Data.GetData(typeof(Product)) is Product product)
                {
                    if(CanAddItems())
                    {
                        int quantity = 1;
                        if (NumberEdit.Execute("Enter Quantity:", 1, int.MaxValue, ref quantity))
                        {
                            var item = CreateItem();
                            item.Product.ID = product.ID;
                            item.Product.Synchronise(product);
                            item.Quantity = quantity;
                            item.Picked = DateTime.MinValue;
                            SaveItem(item);
                            Refresh(false, true);
                        }
                    }
                }
            }
        }

        private void SelectHolding(DynamicMenuColumn column, CoreRow? row)
        {
            if(row is null)
            {
                return;
            }

            var locations = new List<Guid>();
            var holdings = Client.Query(
                new Filter<StockHolding>(x => x.Product.ID).IsEqualTo(row.Get<RequisitionItem, Guid>(c => c.Product.ID)),
                new Columns<StockHolding>(x => x.Location.ID)
                    .Add(x => x.Units));

            foreach (var holding in holdings.Rows)
            {
                var qty = holding.Get<StockHolding, double>(c => c.Units);
                if (!CoreUtils.IsEffectivelyEqual(qty, 0.0F) && qty > 0)
                    locations.Add(holding.Get<StockHolding, Guid>(x => x.Location.ID));
            }

            if (locations.Count == 0)
            {
                MessageWindow.ShowMessage("No valid holdings found for product", "No holdings");
                return;
            }

            var selection = new MultiSelectDialog<StockHolding>
                (
                    new Filter<StockHolding>(x => x.Product.ID).IsEqualTo(row.Get<RequisitionItem, Guid>(c => c.Product.ID))
                    .And(x => x.Location.ID).InList(locations.ToArray())
                    ,
                    new Columns<StockHolding>(
                        x => x.Job.Name,
                        x => x.Job.JobNumber,
                        x => x.Units,
                        x => x.Dimensions.UnitSize,
                        x => x.Dimensions.Height,
                        x => x.Dimensions.Width,
                        x => x.Dimensions.Weight,
                        x => x.Dimensions.Quantity,
                        x => x.Dimensions.Length,
                        x => x.Dimensions.Unit.ID,
                        x => x.Dimensions.Unit.Format,
                        x => x.Dimensions.Unit.Formula,
                        x => x.Dimensions.Unit.HasHeight,
                        x => x.Dimensions.Unit.HasWeight,
                        x => x.Dimensions.Unit.HasWidth,
                        x => x.Dimensions.Unit.HasQuantity,
                        x => x.Dimensions.Unit.HasLength,
                        x => x.Style.ID,
                        x => x.Style.Code,
                        x => x.Style.Description,
                        x => x.Location.ID,
                        x => x.Location.Code,
                        x => x.Location.Description,
                        x => x.Location.Area.Code,
                        x => x.Location.Area.Description
                ), false);

            if (selection.ShowDialog("Units", "0", Syncfusion.Data.FilterType.GreaterThan) == true)
                SelectLocation(selection.Data().Rows.FirstOrDefault(), row);

        }

        private void SelectLocation(CoreRow holdingrow, CoreRow itemrow)
        {
            var item = itemrow.ToObject<RequisitionItem>();
            var holding = holdingrow.ToObject<StockHolding>();
            item.Location.ID = holding.Location.ID;
            item.Location.Code = holding.Location.Code;
            item.Dimensions.CopyFrom(holding.Dimensions, true);
            item.Style.ID = holding.Style.ID;
            item.Style.Code = holding.Style.Code;
            new Client<RequisitionItem>().Save(item, "Changed due to stock holding selection");
            Data.LoadRow(itemrow, item);
            InvalidateRow(itemrow);
        }


        public Requisition? Requisition { get; set; }

        protected override void Reload(Filters<RequisitionItem> criteria, Columns<RequisitionItem> columns, ref SortOrder<RequisitionItem>? sort,
            Action<CoreTable?, Exception?> action)
        {
            criteria.Add(
                new Filter<RequisitionItem>(x => x.RequisitionLink.ID).IsEqualTo(Requisition != null ? Requisition.ID : CoreUtils.FullGuid));

            sort = new SortOrder<RequisitionItem>(x => x.Created);

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

        protected override bool CanDeleteItems(CoreRow[] rows)
        {
            if (Requisition == null || Requisition.ID.Equals(Guid.Empty))
            {
                MessageBox.Show("Please select a Requisition first!");
                return false;
            }

            if (!Requisition.Filled.IsEmpty())
            {
                MessageBox.Show("Cannot Modify a Completed Requisition");
                return false;
            }

            return base.CanDeleteItems(rows);
        }

        public override bool EditItems(RequisitionItem[] items, Func<Type, CoreTable?>? PageDataHandler, bool PreloadPages = false)
        {
            if (Requisition == null || Requisition.ID.Equals(Guid.Empty))
            {
                MessageBox.Show("Please select a Requisition first!");
                return false;
            }

            if (!Requisition.StockUpdated.IsEmpty())
            {
                MessageBox.Show("Cannot Edit Items after Stock Holdings have been updated!");
                return false;
            }

            return base.EditItems(items, PageDataHandler, PreloadPages);
        }

        public override RequisitionItem CreateItem()
        {
            var item = base.CreateItem();
            item.RequisitionLink.ID = Requisition?.ID ?? Guid.Empty;
            item.RequisitionLink.Synchronise(Requisition);
            item.Quantity = 1;
            return item;
        }

        protected override void DoAdd(bool OpenEditorOnDirectEdit = false)
        {
            if (Requisition == null || Requisition.ID.Equals(Guid.Empty))
            {
                MessageBox.Show("Please select a Requisition first!");
                return;
            }

            if (!Requisition.Filled.IsEmpty())
            {
                MessageBox.Show("Cannot Add Items to a Completed Requisition");
                return;
            }

            base.DoAdd();

        }
        
        
    }
}