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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
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; }

        public bool Picked = true;

        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.DefaultStyle.ID);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.ID);
            HiddenColumns.Add(x => x.Product.Dimensions.Length);
            HiddenColumns.Add(x => x.Product.Dimensions.Width);
            HiddenColumns.Add(x => x.Product.Dimensions.Height);
            HiddenColumns.Add(x => x.Product.Dimensions.Weight);
            HiddenColumns.Add(x => x.Product.Dimensions.UnitSize);
            HiddenColumns.Add(x => x.Product.Dimensions.Value);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.HasQuantity);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.HasLength);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.HasWidth);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.HasWeight);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.HasHeight);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.Formula);
            HiddenColumns.Add(x => x.Product.Dimensions.Unit.Format);
            //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);
            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)
            );
        }
        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.DragTarget)
                .EndUpdate();
        }

        protected override void DoBeforeSave(IDynamicEditorForm editor, RequisitionItem[] items)
        {
            base.DoBeforeSave(editor, items);

            foreach (var item in items)
                item.Picked = Picked ? DateTime.Now : DateTime.MinValue;
        }

        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 = Picked ? DateTime.Now : DateTime.MinValue;
                            SaveItem(item);
                            Refresh(false, true);
                        }
                    }
                }
            }
        }

        private void SelectHolding(DynamicMenuColumn column, CoreRow? row)
        {
            List<Guid> locations = new List<Guid>();
            var holdings = new Client<StockHolding>().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)
            {
                MessageBox.Show("No valid holdings found for product");
                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));

            if (Picked)
                criteria.Add(new Filter<RequisitionItem>(x => x.Picked).IsNotEqualTo(DateTime.MinValue));
            else
                criteria.Add(new Filter<RequisitionItem>(x => x.Picked).IsEqualTo(DateTime.MinValue));

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

            base.Reload(
                criteria,
                columns,
                ref sort,
                (o, e) =>
                {
                    // Update Buttons Here
                    action.Invoke(o, e);
                }
            );
        }

        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);
        }

        protected 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();

        }
        
        
    }
}