prs/prs.desktop/Panels/PurchaseOrders/SupplierPurchaseOrderItemOneToMany.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;

namespace PRSDesktop;

public class SupplierPurchaseOrderItemOneToMany : DynamicOneToManyGrid<PurchaseOrder,PurchaseOrderItem>
{
    private Button bill;
    private Button? createConsignment;
    //private Button? viewconsign;
    private Button receive;
    private Button assignLocation;

    private List<Tuple<PurchaseOrderItem, JobRequisitionItemPurchaseOrderItem>> JobRequisitionItems = new();

    public SupplierPurchaseOrderItemOneToMany() : base()
    {
        
        
        
        HiddenColumns.Add(x => x.ID);

        HiddenColumns.Add(x => x.Description);
        HiddenColumns.Add(x => x.TaxRate);
        HiddenColumns.Add(x => x.ExTax);
        HiddenColumns.Add(x => x.Tax);
        HiddenColumns.Add(x => x.IncTax);
        HiddenColumns.Add(x => x.ReceivedDate);
        HiddenColumns.Add(x => x.Qty);
        HiddenColumns.Add(x => x.Balance);
        HiddenColumns.Add(x => x.PORevision);
        HiddenColumns.Add(x => x.DueDate);
        HiddenColumns.Add(x => x.SupplierCode);

        HiddenColumns.Add(x => x.BillLine.ID);
        HiddenColumns.Add(x => x.Consignment.ID);

        HiddenColumns.Add(x => x.Job.ID);
        HiddenColumns.Add(x => x.StockLocation.ID);
        HiddenColumns.Add(x => x.PurchaseGL.ID);
        HiddenColumns.Add(x => x.CostCentre.ID);
        HiddenColumns.Add(x => x.Product.ID);
        HiddenColumns.Add(x => x.Product.Code);
        HiddenColumns.Add(x => x.Product.Name);
        HiddenColumns.Add(x => x.Style.ID);

        HiddenColumns.Add(x => x.TaxCode.ID);
        HiddenColumns.Add(x => x.TaxCode.Code);
        HiddenColumns.Add(x => x.TaxCode.Description);
        HiddenColumns.Add(x => x.TaxCode.Rate);

        HiddenColumns.Add(x => x.PostedReference);

        foreach (var column in Columns.None<PurchaseOrderItem>()
            .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Local))
        {
            HiddenColumns.Add(column);
        }

        HiddenColumns.Add(x => x.PurchaseOrderLink.SupplierLink.ID);
        HiddenColumns.Add(x => x.PurchaseOrderLink.Category.ID);

        HiddenColumns.Add(x => x.Product.DigitalForm.ID);
        HiddenColumns.Add(x => x.Product.DigitalForm.Description);

        HiddenColumns.Add(x => x.Product.Image.ID);
        HiddenColumns.Add(x => x.Product.Image.FileName);
        ActionColumns.Add(new DynamicImageManagerColumn<PurchaseOrderItem>(this, x => x.Product.Image, true)
        { Position = DynamicActionColumnPosition.Start });

        HiddenColumns.Add(x => x.FormCount);
        HiddenColumns.Add(x => x.OpenForms);
        ActionColumns.Add(new DynamicMenuColumn(BuildFormsMenu) { Position = DynamicActionColumnPosition.End });
        ActionColumns.Add(new DynamicImageColumn(FormsImage) { Position = DynamicActionColumnPosition.Start, ToolTip = FormsToolTip });
        
    }



    protected override void Init()
    {
        base.Init();
        
        AddButton("Catalog", PRSDesktop.Resources.product.AsBitmapImage(), SearchProducts);

        if (Security.IsAllowed<CanViewConsignmentModule>())
        {
            createConsignment = AddButton("Add to Consignment", null, AddToConsignment);
            createConsignment.IsEnabled = false;
        }

        receive = AddButton("Receive Items", null, ReceiveItems);
        receive.IsEnabled = false;

        bill = AddButton("Enter Bill", null, EnterBill);
        bill.IsEnabled = false;

        assignLocation = AddButton("Assign Location", null, AssignLocation);
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);
        if (!ReadOnly && Security.CanEdit<PurchaseOrderItem>())
        {
            options.DirectEdit = true;
            options.DragTarget = true;
        }
        //if (!IsDirectEditMode(options))
        //{
        options.FilterRows = true;
        //}
    }

    protected override void OnAfterRefresh()
    {
        base.OnAfterRefresh();

        JobRequisitionItems.RemoveAll(x => !DataComponent.Items.Contains(x.Item1));
    }

    public override void AfterSave(object item)
    {
        base.AfterSave(item);

        var toSave = new List<JobRequisitionItemPurchaseOrderItem>();
        foreach (var poItem in DataComponent.Items)
        {
            var jriPois = JobRequisitionItems.Where(x => x.Item1 == poItem).Select(x => x.Item2);
            foreach (var jriPoi in jriPois)
            {
                jriPoi.PurchaseOrderItem.ID = poItem.ID;
            }
            toSave.AddRange(jriPois);
        }
        Client.Save(toSave, "");
    }

    private void BuildFormsMenu(DynamicMenuColumn column, CoreRow? row)
    {
        if (row == null) return;

        if (Security.CanEdit<PurchaseOrderItem>())
        {
            column.AddItem("Split Line", PRSDesktop.Resources.split, SplitLine, enabled: row.Get<PurchaseOrderItem, DateTime>(x => x.ReceivedDate).IsEmpty());
        }

        if(row.Get<PurchaseOrderItem, Guid>(x => x.Consignment.ID) != Guid.Empty)
        {
            column.AddItem("View Consignment", null, ViewConsignment);
        }

        var formsItem = column.AddItem("Digital Forms", PRSDesktop.Resources.kanban, null);
        DynamicGridUtils.PopulateFormMenu<PurchaseOrderItemForm, PurchaseOrderItem, PurchaseOrderItemLink>(
            formsItem,
            row.Get<PurchaseOrderItem, Guid>(x => x.ID),
            row.ToObject<PurchaseOrderItem>);
    }

    private void SplitLine(CoreRow? row)
    {
        if (row is null)
            return;

        var qty = row.Get<PurchaseOrderItem, double>(x => x.Qty);
        var value = qty / 2;
        if(DoubleEdit.Execute("Enter quantity to split on:", 0.0, qty, ref value))
        {
            var poi = DataComponent.LoadItem(row);

            IEnumerable<Guid> jobRequiItemIDs;
            if(poi.ID == Guid.Empty)
            {
                // If not saved yet, we will have any jriPOIs in the transient list.
                jobRequiItemIDs = JobRequisitionItems.Where(x => x.Item1 == poi).Select(x => x.Item2.JobRequisitionItem.ID).ToList();
            }
            else
            {
                // Otherwise, they'll all be in the database.
                jobRequiItemIDs = Client.Query(
                    new Filter<JobRequisitionItemPurchaseOrderItem>(x => x.PurchaseOrderItem.ID).IsEqualTo(poi.ID),
                    Columns.None<JobRequisitionItemPurchaseOrderItem>().Add(x => x.JobRequisitionItem.ID))
                    .ExtractValues<JobRequisitionItemPurchaseOrderItem, Guid>(x => x.JobRequisitionItem.ID);
            }

            var newLine = new PurchaseOrderItem
            {
            };
            newLine.BillLine.ID = poi.BillLine.ID;
            newLine.BillLine.Synchronise(poi.BillLine);
            newLine.StockLocation.ID = poi.StockLocation.ID;
            newLine.StockLocation.Synchronise(poi.StockLocation);
            newLine.Consignment.ID = poi.Consignment.ID;
            newLine.Consignment.Synchronise(poi.Consignment);
            newLine.PurchaseGL.ID = poi.PurchaseGL.ID;
            newLine.PurchaseGL.Synchronise(poi.PurchaseGL);
            newLine.CostCentre.ID = poi.CostCentre.ID;
            newLine.CostCentre.Synchronise(poi.CostCentre);
            newLine.Product.ID = poi.Product.ID;
            newLine.Product.Synchronise(poi.Product);
            newLine.Style.ID = poi.Style.ID;
            newLine.Style.Synchronise(poi.Style);
            newLine.TaxCode.ID = poi.TaxCode.ID;
            newLine.TaxCode.Synchronise(poi.TaxCode);
            newLine.PurchaseOrderLink.ID = poi.PurchaseOrderLink.ID;
            newLine.PurchaseOrderLink.Synchronise(poi.PurchaseOrderLink);
            newLine.Job.ID = poi.Job.ID;
            newLine.Job.Synchronise(poi.Job);
            newLine.Dimensions.CopyFrom(poi.Dimensions);

            // Copying across the posted reference; this would be a problem if we were to try to sync via a Poster two purchase order items with the
            // original posted single line; however, after discussing with Frank, we can't imagine a place where we would do this; we would generally replace
            // the posted lines. Hence, we can copy the posted reference.
            newLine.PostedReference = poi.PostedReference;

            newLine.Description = poi.Description;
            newLine.TaxRate = poi.TaxRate;
            newLine.ExTax = poi.ExTax;
            newLine.Tax = poi.Tax;
            newLine.IncTax = poi.IncTax;
            newLine.Cost = poi.Cost;
            newLine.Balance = poi.Balance;
            newLine.PORevision = poi.PORevision;
            newLine.DueDate = poi.DueDate;
            newLine.SupplierCode = poi.SupplierCode;

            poi.Qty = value;
            newLine.Qty = qty - value;

            foreach(var jriID in jobRequiItemIDs)
            {
                // Add to a list to be saved later.
                var jriPoi = new JobRequisitionItemPurchaseOrderItem();
                jriPoi.JobRequisitionItem.ID = jriID;
                JobRequisitionItems.Add(new(newLine, jriPoi));
            }

            DataComponent.SaveItem(poi);
            DataComponent.SaveItem(newLine);
            Refresh(false, true);
            DoChanged();
        }
    }

    private void ViewConsignment(CoreRow? row)
    {
        if (row is null) return;

        var consignmentID = row.Get<PurchaseOrderItem, Guid>(x => x.Consignment.ID);
        var consignments = Client.Query(
            new Filter<Consignment>(x => x.ID).IsEqualTo(consignmentID),
            DynamicGridUtils.LoadEditorColumns(Columns.None<Consignment>()))
            .ToObjects<Consignment>().ToArray();
        DynamicGridUtils.CreateDynamicGrid(typeof(DynamicDataGrid<>), typeof(Consignment)).EditItems(consignments);
    }

    private FrameworkElement? FormsToolTip(DynamicActionColumn arg1, CoreRow? arg2)
    {
        var text = arg2 == null || arg2.Get<PurchaseOrderItem, Guid>(x => x.Product.DigitalForm.ID) == Guid.Empty
            ? ""
            : arg2.Get<PurchaseOrderItem, int>(c => c.FormCount) == 0
                ? "No forms found for this item"
                : arg2.Get<PurchaseOrderItem, int>(c => c.OpenForms) > 0
                    ? "Incomplete forms found"
                    : "All forms completed";
        return string.IsNullOrWhiteSpace(text) ? null : arg1.TextToolTip(text);
    }

    private BitmapImage? FormsImage(CoreRow? arg)
    {
        if (arg == null)
            return PRSDesktop.Resources.quality.AsBitmapImage();
        return arg.Get<PurchaseOrderItem, Guid>(x => x.Product.DigitalForm.ID) == Guid.Empty
            ? null
            : arg.Get<PurchaseOrderItem, int>(c => c.FormCount) == 0
                ? PRSDesktop.Resources.warning.AsBitmapImage()
                : arg.Get<PurchaseOrderItem, int>(c => c.OpenForms) > 0
                    ? PRSDesktop.Resources.warning.AsBitmapImage()
                    : PRSDesktop.Resources.quality.AsBitmapImage();
    }

    private bool AddToConsignment(Button sender, CoreRow[] rows)
    {
        if (!rows.Any())
        {
            MessageBox.Show("Please select a row first");
            return false;
        }

        var poItems = DataComponent.LoadItems(rows);
        if(poItems.Any(x => x.ID == Guid.Empty))
        {
            MessageBox.Show("Please save this purchase order first.");
            return false;
        }

        var menu = new ContextMenu();
        menu.AddItem("New Consignment", null, () =>
        {
            var consign = new Consignment();
            consign.Supplier.ID = rows.First().Get<PurchaseOrderItem, Guid>(x => x.PurchaseOrderLink.SupplierLink.ID);
            consign.Category.ID = rows.First().Get<PurchaseOrderItem, Guid>(x => x.PurchaseOrderLink.Category.ID);

            if (new DynamicDataGrid<Consignment>().EditItems(new[] { consign }, LoadConsignmentLines, true))
            {
                foreach (var item in poItems)
                {
                    item.Consignment.ID = consign.ID;
                }
                new Client<PurchaseOrderItem>().Save(poItems, "Added to new consignment");
                Refresh(false, true);
            }
        });
        menu.AddItem("Existing Consignment", null, () =>
        {
            var popupList = new PopupList(typeof(Consignment), Guid.Empty, Array.Empty<string>());
            popupList.OnDefineFilter += type =>
            {
                return new Filter<Consignment>(x => x.Closed).IsNotEqualTo(DateTime.MinValue);
            };
            if (popupList.ShowDialog() == true)
            {
                foreach (var item in poItems)
                {
                    item.Consignment.ID = popupList.ID;
                }
                new Client<PurchaseOrderItem>().Save(poItems, "Added to existing consignment");
                Refresh(false, true);
            }
        });
        menu.IsOpen = true;

        return false;
    }

    private CoreTable? LoadConsignmentLines(Type type)
    {
        if (type == typeof(PurchaseOrderItem))
        {
            var result = new CoreTable();
            result.LoadColumns(typeof(PurchaseOrderItem));
            result.LoadRows(SelectedRows);
            return result;
        }
        else
        {
            return null;
        }
    }

    private static bool EnterBill(Button sender, CoreRow[] rows)
    {
        if (!rows.Any())
        {
            MessageBox.Show("Please select a row first");
            return false;
        }

        var bill = new Bill();
        bill.SupplierLink.ID = rows.First()
            .Get<PurchaseOrderItem, Guid>(x => x.PurchaseOrderLink.SupplierLink.ID);
        bill.BillDate = DateTime.Today;
        return new DynamicDataGrid<Bill>().EditItems(new[] { bill }, (type) =>
        {
            return LoadBillLines(type, rows);
        }, true);
    }
    private static CoreTable LoadBillLines(Type type, CoreRow[] rows)
    {
        var result = new CoreTable();
        result.LoadColumns(typeof(BillLine));
        foreach (var row in rows)
        {
            var billrow = result.NewRow();
            billrow.Set<BillLine, Guid>(x => x.OrderItem.ID, row.Get<PurchaseOrderItem, Guid>(x => x.ID));

            var description = new List<string>();
            if (row.Get<PurchaseOrderItem, Guid>(x => x.Product.ID) != Guid.Empty)
                description.Add(string.Format("{0} : {1}", row.Get<PurchaseOrderItem, string>(x => x.Product.Code),
                    row.Get<PurchaseOrderItem, string>(x => x.Product.Name)));
            var Description = row.Get<PurchaseOrderItem, string>(x => x.Description);
            if (!string.IsNullOrEmpty(Description))
                description.Add(Description);
            billrow.Set<BillLine, string>(x => x.Description, string.Join("\n", description));

            billrow.Set<BillLine, Guid>(x => x.TaxCode.ID, row.Get<PurchaseOrderItem, Guid>(x => x.TaxCode.ID));
            billrow.Set<BillLine, string>(x => x.TaxCode.Code, row.Get<PurchaseOrderItem, string>(x => x.TaxCode.Code));
            billrow.Set<BillLine, string>(x => x.TaxCode.Description, row.Get<PurchaseOrderItem, string>(x => x.TaxCode.Description));
            billrow.Set<BillLine, double>(x => x.TaxCode.Rate, row.Get<PurchaseOrderItem, double>(x => x.TaxCode.Rate));
            billrow.Set<BillLine, double>(x => x.TaxRate, row.Get<PurchaseOrderItem, double>(x => x.TaxRate));
            billrow.Set<BillLine, double>(x => x.ExTax, row.Get<PurchaseOrderItem, double>(x => x.ExTax));
            billrow.Set<BillLine, double>(x => x.Tax, row.Get<PurchaseOrderItem, double>(x => x.Tax));
            billrow.Set<BillLine, double>(x => x.IncTax, row.Get<PurchaseOrderItem, double>(x => x.IncTax));
            result.Rows.Add(billrow);
        }

        return result;
    }

    private bool ReceiveItems(Button sender, CoreRow[] rows)
    {
        if (!rows.Any())
        {
            MessageBox.Show("Please select a row first");
            return false;
        }

        var now = DateTime.Now;
        using (new WaitCursor())
        {
            var items = DataComponent.LoadItems(rows);
            foreach (var item in items)
                item.ReceivedDate = item.ReceivedDate.IsEmpty() ? now : DateTime.MinValue;
            now = items.Select(x => x.ReceivedDate).FirstOrDefault();
            new Client<PurchaseOrderItem>().Save(items, now.IsEmpty() ? "Cleared Received Date" : $"Updated Received Date to {now:g}");
        }

        return true;
    }

    public static bool AssignLocation(Button btn, CoreRow[] rows)
    {
        if (!rows.Any())
        {
            MessageBox.Show("Please select at least one row to assign");
            return false;
        }

        var menu = new ContextMenu();
        menu.AddItem("Create New Location", null, () =>
        {
            var grid = new StockLocationGrid();
            var location = new StockLocation();
            if (grid.EditItems(new StockLocation[] { location }))
                AssignLocationToItems(location.ID, rows);
        });
        menu.AddItem("Choose Existing", null, () =>
        {
            var popup = new PopupList(typeof(StockLocation), Guid.Empty, new string[] { });
            if (popup.ShowDialog() == true)
                AssignLocationToItems(popup.ID, rows);
        });
        menu.IsOpen = true;
        return true;
    }

    private static void AssignLocationToItems(Guid locationID, CoreRow[] rows)
    {
        var items = new List<PurchaseOrderItem>();
        foreach (CoreRow row in rows)
        {
            var item = row.ToObject<PurchaseOrderItem>();
            item.StockLocation.ID = locationID;
            items.Add(item);
        }
        Client.Save(items, "Added stock location from PurchaseOrderItem Grid");
    }

    /*private StockLocation[] QueryLocations()
    {
        CoreTable table = new Client<StockLocation>().Query(new Filter<StockLocation>(x => x.Active).IsEqualTo(true), new Columns<StockLocation>(x => x.ID));
        List<StockLocation> locations = new List<StockLocation>();
        foreach (CoreRow row in table.Rows)
            locations.Add(row.ToObject<StockLocation>());

        return locations.ToArray();
    }*/


    public override void SelectItems(CoreRow[]? rows)
    {
        // Check if we can actually edit the selected lines
        var _editable = !ReadOnly && Security.CanEdit<Consignment>();
        
        // Check to ensure NO selected lines are received
        var _allunreceived = rows?.All(r => r.Get<PurchaseOrderItem, DateTime>(c => c.ReceivedDate).IsEmpty()) == true;
        
        // Check to ensure ALL select lines are received
        var _allreceived = rows?.All(r => !r.Get<PurchaseOrderItem, DateTime>(c => c.ReceivedDate).IsEmpty()) == true;
        
        // Check to ensure NO selected lines are already linked to a PO
        var _anyconsigmments = rows?.Any(r => r.Get<PurchaseOrderItem,Guid>(c=>c.Consignment.ID) != Guid.Empty) == true;
        
        // Check to Ensure NO selected lines are already linked to a Bill
        var _anybills = rows?.Any(r => r.Get<PurchaseOrderItem,Guid>(c=>c.BillLine.ID) != Guid.Empty) == true;

        if (createConsignment != null)
        {
            createConsignment.IsEnabled =
                _anyconsigmments == false
                && _allunreceived
                && _editable;
        }

        receive.Content = _allreceived
            ? "Un-Receive Items"
            : "Receive Items";
        
        receive.IsEnabled =
            _anyconsigmments == false
            && (_allreceived || _allunreceived)
            && _editable;

        bill.IsEnabled =
            _anybills == false
            && _editable;

        assignLocation.IsEnabled =
            rows != null && !ReadOnly && Security.CanEdit<PurchaseOrderItem>();

        base.SelectItems(rows);
    }
    
    private bool SearchProducts(Button button, CoreRow[] rows)
    {
        var dlg = new MultiSelectDialog<ProductInstance>(
            new Filter<ProductInstance>().All(),
            Columns.None<ProductInstance>()
                .Add(x => x.ID)
                .Add(x => x.Product.ID)
                .Add(x => x.Product.Code)
                .Add(x => x.Product.Name)
                .Add(x => x.Product.TaxCode.ID)
                .Add(x => x.Product.TaxCode.Code)
                .Add(x => x.Product.TaxCode.Description)
                .Add(x => x.Product.TaxCode.Rate)
                .Add(x => x.Product.PurchaseGL.ID)
                .Add(x => x.Product.PurchaseGL.Code)
                .Add(x => x.Product.PurchaseGL.Description)
                .Add(x => x.Product.CostCentre.ID)
                .Add(x => x.Product.CostCentre.Code)
                .Add(x => x.Product.CostCentre.Description)
                .Add(x => x.Style.ID)
                .Add(x => x.Style.Code)
                .Add(x => x.Style.Description)
                .AddDimensionsColumns(x => x.Dimensions)
                .Add(x => x.NettCost),
            false
        );
        if (dlg.ShowDialog() == true)
        {
            CreateItems(() =>
            {
                var result = new List<PurchaseOrderItem>();
                var pi = dlg.Data().Rows.FirstOrDefault()?.ToObject<ProductInstance>();
                if (pi == null)
                    return result;
                
                var sp = new Client<SupplierProduct>().Query(
                    new Filter<SupplierProduct>(x => x.Product.ID).IsEqualTo(pi.Product.ID)
                        .And(x=>x.Style.ID).IsEqualTo(pi.Style.ID)
                        .And(x=>x.Dimensions).DimensionEquals(pi.Dimensions),
                    Columns.None<SupplierProduct>().Add(x => x.ID)
                        .Add(x => x.Product.ID)
                        .Add(x => x.Product.Code)
                        .Add(x => x.Product.Name)
                        .Add(x => x.Product.TaxCode.ID)
                        .Add(x => x.Product.TaxCode.Code)
                        .Add(x => x.Product.TaxCode.Description)
                        .Add(x => x.Product.TaxCode.Rate)
                        .Add(x => x.Product.PurchaseGL.ID)
                        .Add(x => x.Product.PurchaseGL.Code)
                        .Add(x => x.Product.PurchaseGL.Description)
                        .Add(x => x.Product.CostCentre.ID)
                        .Add(x => x.Product.CostCentre.Code)
                        .Add(x => x.Product.CostCentre.Description)
                        .Add(x => x.Style.ID)
                        .Add(x => x.Style.Code)
                        .Add(x => x.Style.Description)
                        .Add(x=>x.Job.ID)
                        .Add(x=>x.Job.JobNumber)
                        .Add(x=>x.Job.Name)
                        .AddDimensionsColumns(x => x.Dimensions)
                        .Add(x => x.CostPrice)
                        .Add(x => x.ForeignCurrencyPrice)
                ).Rows.FirstOrDefault()?.ToObject<SupplierProduct>();

                if (sp != null)
                {
                    var poi = CreateItem();
                    poi.Product.ID = sp.Product.ID;
                    poi.Product.Synchronise(sp.Product);
                    poi.Style.ID = sp.Style.ID;
                    poi.Style.Synchronise(sp.Style);
                    poi.Dimensions.CopyFrom(sp.Dimensions);
                    poi.Job.ID = sp.Job.ID;
                    poi.Job.Synchronise(sp.Job);
                    poi.ForeignCurrencyCost = sp.ForeignCurrencyPrice;
                    poi.Cost = sp.CostPrice;
                    result.Add(poi);
                }
                else if (pi != null)
                {
                    var poi = CreateItem();
                    poi.Product.ID = pi.Product.ID;
                    poi.Product.Synchronise(pi.Product);
                    poi.Style.ID = pi.Style.ID;
                    poi.Style.Synchronise(pi.Style);
                    poi.Dimensions.CopyFrom(pi.Dimensions);
                    poi.Cost = pi.NettCost;
                    result.Add(poi);
                }
                return result;
            });
        }
        return false;
    }

    protected override void DoAdd(bool OpenEditorOnDirectEdit = false)
    {
        var dlg = new MultiSelectDialog<SupplierProduct>(
            new Filter<SupplierProduct>(x => x.SupplierLink.ID).IsEqualTo(Item.SupplierLink.ID),
            Columns.None<SupplierProduct>().Add(x => x.ID)
                .Add(x => x.Product.ID)
                .Add(x => x.Product.Code)
                .Add(x => x.Product.Name)
                .Add(x => x.Product.TaxCode.ID)
                .Add(x => x.Product.TaxCode.Code)
                .Add(x => x.Product.TaxCode.Description)
                .Add(x => x.Product.TaxCode.Rate)
                .Add(x => x.Product.PurchaseGL.ID)
                .Add(x => x.Product.PurchaseGL.Code)
                .Add(x => x.Product.PurchaseGL.Description)
                .Add(x => x.Product.CostCentre.ID)
                .Add(x => x.Product.CostCentre.Code)
                .Add(x => x.Product.CostCentre.Description)
                .Add(x => x.Style.ID)
                .Add(x => x.Style.Code)
                .Add(x => x.Style.Description)
                .Add(x=>x.Job.ID)
                .Add(x=>x.Job.JobNumber)
                .Add(x=>x.Job.Name)
                .AddDimensionsColumns(x => x.Dimensions)
                .Add(x => x.CostPrice)
                .Add(x => x.ForeignCurrencyPrice),
            false
        );
        if (dlg.ShowDialog() == true)
        {
            CreateItems(() =>
            {
                var result = new List<PurchaseOrderItem>();
                var sp = dlg.Data().Rows.FirstOrDefault()?.ToObject<SupplierProduct>();
                if (sp != null)
                {
                    var poi = CreateItem();
                    poi.Product.ID = sp.Product.ID;
                    poi.Product.Synchronise(sp.Product);
                    poi.Style.ID = sp.Style.ID;
                    poi.Style.Synchronise(sp.Style);
                    poi.Dimensions.CopyFrom(sp.Dimensions);
                    poi.Job.ID = sp.Job.ID;
                    poi.Job.Synchronise(sp.Job);
                    poi.ForeignCurrencyCost = sp.ForeignCurrencyPrice;
                    poi.Cost = sp.CostPrice;
                    result.Add(poi);
                }
                return result;
            });
        }
    }
    
    protected override void ConfigureColumns(DynamicGridColumns columns)
    {
        base.ConfigureColumns(columns);
        var editor = columns
            .FirstOrDefault(x => String.Equals(x.ColumnName, nameof(BillLine.ForeignCurrencyCost)))?.Editor as CurrencyEditor;
        if (editor != null)
            editor.CurrencySymbol = Item.SupplierLink.Currency.Symbol;
    }

    protected override void CustomiseEditor(PurchaseOrderItem[] items, DynamicGridColumn column, BaseEditor editor)
    {
        base.CustomiseEditor(items, column, editor);

        if(items.Any(x => x.ReceivedDate != DateTime.MinValue) && !new Column<PurchaseOrderItem>(x => x.ReceivedDate).IsEqualTo(column.ColumnName) && editor.Editable == Editable.Enabled)
        {
            editor.Editable = editor.Editable.Combine(Editable.Disabled);
        }
    }
    
    protected override void DoReconfigureEditors(DynamicEditorGrid grid, PurchaseOrderItem[] items)
    {
        base.DoReconfigureEditors(grid, items);
        var fcp = grid.FindEditor(nameof(PurchaseOrderItem.ForeignCurrencyCost)) as CurrencyEditorControl;
        if (fcp != null)
        {
            fcp.SetEnabled(items.All(x=>x.PurchaseOrderLink.SupplierLink.Currency.ID != Guid.Empty));
            fcp.CurrencySymbol = items.First().PurchaseOrderLink.SupplierLink.Currency.Symbol;
        }
        var tp = grid.FindEditor(nameof(PurchaseOrderItem.Cost));
        if (tp != null)
        {
            tp.SetEnabled(items.All(x=>x.PurchaseOrderLink.SupplierLink.Currency.ID == Guid.Empty));
        }
    }
    

    protected override void OnAfterEditorValueChanged(DynamicEditorGrid? grid, PurchaseOrderItem[] items, AfterEditorValueChangedArgs args, Dictionary<string, object?> changes)
    {
        base.OnAfterEditorValueChanged(grid, items, args, changes);
        if (args.ColumnName.Equals("Product.ID") || args.ColumnName.Equals("Job.ID") || args.ColumnName.Equals("Dimensions") || args.ColumnName.StartsWith("Dimensions.") || args.ColumnName.Equals("Style.ID"))
        {
            PurchaseOrder.UpdateCosts(
                items, 
                Item.SupplierLink.ID,
                changes
            );
        }
    }

    protected override Dictionary<string, object?> EditorValueChanged(IDynamicEditorForm editor, PurchaseOrderItem[] items, string name,
        object value)
    {
        var results = base.EditorValueChanged(editor, items, name, value);
        if (name.Equals("ProductLink.TaxCode.ID"))
            DynamicGridUtils.UpdateEditorValue(items, "TaxCode.ID", (Guid)value, results);
        return results;
    }
}