prs/prs.desktop/Panels/Reservation Management/Purchasing/ReservationManagementPurchasing.xaml.cs

using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.DynamicGrid;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Windows.Controls;

namespace PRSDesktop;

/// <summary>
/// Interaction logic for JobRequisitionPurchasing.xaml
/// </summary>
public partial class ReservationManagementPurchasing : UserControl
{
    public delegate void PurchaseOrderSaved();
    public event PurchaseOrderSaved? OnPurchaseOrderSaved;

    private PurchaseOrder Order { get; set; } = new PurchaseOrder();

    private List<JobRequiItemLinking> JobRequiItems = new List<JobRequiItemLinking>();

    private class JobRequiItemLinking
    {
        public JobRequisitionItem JobRequiItem { get; set; }

        public PurchaseOrderItemAllocation? POAllocation { get; set; }

        public PurchaseOrderItem? PurchaseOrderItem { get; set; }

        public JobRequiItemLinking(JobRequisitionItem jobRequiItem, PurchaseOrderItem purchaseOrderItem)
        {
            JobRequiItem = jobRequiItem;
            PurchaseOrderItem = purchaseOrderItem;
            POAllocation = null;
        }

        public JobRequiItemLinking(JobRequisitionItem jobRequiItem, PurchaseOrderItemAllocation poAllocation)
        {
            JobRequiItem = jobRequiItem;
            PurchaseOrderItem = null;
            POAllocation = poAllocation;
        }
    }

    bool bLoaded = false;
    public bool EditorChanged { get; private set; }

    public ReservationManagementPurchasing()
    {
        InitializeComponent();
        CreatePOEditor();
    }

    private void ReloadJobRequiItems(Guid orderID)
    {
        JobRequiItems.Clear();

        if(orderID != Guid.Empty)
        {
            var _allocations = Client.Query(
                new Filter<PurchaseOrderItemAllocation>(x => x.Item.PurchaseOrderLink.ID).IsEqualTo(orderID),
                Columns.None<PurchaseOrderItemAllocation>().Add(x => x.ID).Add(x => x.JobRequisitionItem.ID))
                .ToObjects<PurchaseOrderItemAllocation>();
            foreach (var _allocation in _allocations)
            {
                var jri = new JobRequisitionItem
                {
                    ID = _allocation.JobRequisitionItem.ID
                };
                JobRequiItems.Add(new JobRequiItemLinking(jri, _allocation));
            }
        }
    }

    public void LoadFromRequiLine(Guid orderID)
    {
        if (bLoaded)
            return;

        ReloadJobRequiItems(orderID);

        if (orderID != Guid.Empty)
        {
            if (orderID != Order.ID)
            {
                LoadPO(orderID);
            }
        }
        else
            ClearEditor();
    }

    private void LoadPO(Guid orderID)
    {
        var po = Client.Query(
            new Filter<PurchaseOrder>(x => x.ID).IsEqualTo(orderID),
            Columns.None<PurchaseOrder>().Add(
                x => x.ID,
                x => x.SupplierLink.ID,
                x => x.SupplierLink.Code,
                x => x.SupplierLink.Name,
                x => x.Description,
                x => x.Category.ID,
                x => x.Category.Code,
                x => x.Category.Description,
                x => x.RaisedBy.ID,
                x => x.RaisedBy.Code,
                x => x.RaisedBy.Name,
                x => x.DueDate,
                x => x.IssuedBy.ID,
                x => x.IssuedBy.Code,
                x => x.IssuedBy.Name,
                x => x.IssuedDate,
                x => x.ClosedDate,
                x => x.PONumber))
            .ToObjects<PurchaseOrder>().FirstOrDefault();
        if (po is not null)
        {
            Order = po;
            CreatePOEditor(new BaseObject[] { po });
        }
    }

    private void CreatePOEditor(BaseObject[]? items = null)
    {
        DetailBorder.Child = null;

        Editor = new EmbeddedDynamicEditorForm();
        Editor.SetLayoutType<VerticalDynamicEditorGridLayout>();
        Editor.SetValue(Grid.RowProperty, 1);
        Editor.SetValue(Grid.ColumnProperty, 0);
        Editor.SetValue(Grid.ColumnSpanProperty, 4);
        Editor.HighlightButtons = true;
        Editor.HideButtons = true;
        
        EditorChanged = false;

        Editor.OnAfterEditorValueChanged += (sender, args) =>
        {
            EditorChanged = true;
            Editor.HideButtons = false;
            return null;
        };

        Editor.OnOK += () =>
        {
            var cancel = new System.ComponentModel.CancelEventArgs();
            Editor.SaveItem(cancel);
            Editor.HideButtons = true;

            SaveJRIPOIs();

            OnPurchaseOrderSaved?.Invoke();
            EditorChanged = false;
            bLoaded = false;
        };
        Editor.OnCancel += () =>
        {                
            Editor.HideButtons = true;
            bLoaded = false;

            var orderID = Order.ID;

            Order = new PurchaseOrder();
            JobRequiItems.Clear();

            LoadFromRequiLine(orderID);

            EditorChanged = false;
        };
        Editor.OnChanged += (sender, args) =>
        {
            EditorChanged = true;
            Editor.HideButtons = false;
        };

        DetailBorder.Child = Editor;

        var grid = DynamicGridUtils.CreateDynamicGrid(typeof(DynamicDataGrid<>), typeof(PurchaseOrder));
        grid.InitialiseEditorForm(Editor, items ?? new object[] { new PurchaseOrder() });

        var loadPO = new Button
        {
            Content = "Load PO",
            Height = 30,
            Margin = new System.Windows.Thickness(2, 0, 0, 0),
            Padding = new System.Windows.Thickness(15, 0, 15, 0)
        };
        loadPO.Click += LoadPO_Click;
        Editor.AddButton(loadPO);
    }

    private void LoadPO_Click(object sender, System.Windows.RoutedEventArgs e)
    {
        var popup = new PopupList(typeof(PurchaseOrder), Guid.Empty, Array.Empty<string>());
        if(popup.ShowDialog() == true)
        {
            bLoaded = true;
            LoadPO(popup.ID);
        }
    }

    private void SaveJRIPOIs()
    {
        var jriPois = new List<PurchaseOrderItemAllocation>();
        var jris = new List<JobRequisitionItem>();
        foreach(var item in JobRequiItems)
        {
            if(item.PurchaseOrderItem is not null)
            {
                var jriPoi = new PurchaseOrderItemAllocation();
                jriPoi.Job.ID = item.JobRequiItem.Job.ID;
                jriPoi.JobRequisitionItem.ID = item.JobRequiItem.ID;
                jriPoi.Item.ID = item.PurchaseOrderItem.ID;
                jriPoi.Quantity = item.PurchaseOrderItem.Qty;
                jriPois.Add(jriPoi);

                item.POAllocation = jriPoi;
                jris.Add(item.JobRequiItem);
            }
        }

        Client.Save(
            jriPois,
            "Updated from Job Requi Review Create Purchase Order");
        Client.Save(
            jris,
            "Marked as on order");
    }

    private void ClearEditor()
    {
        Order = new PurchaseOrder();
        CreatePOEditor();
    }

    public void DropItems(IList<CoreRow> rows)
    {
        var page = Editor.Pages.OfType<SupplierPurchaseOrderItemOneToMany>().First();

        if(CreatePOItemsFromRequiItems(rows.ToArray<JobRequisitionItem>(), page.Items))
        {
            page.Refresh(false, true);
            page.DoChanged();
        }
    }

    public bool CreatePOItemsFromRequiItems(IList<JobRequisitionItem> selected, List<PurchaseOrderItem> items)
    {
        // These columns probably are already there, but if they aren't, let's load them.
        Client.EnsureColumns(selected,
            Columns.None<JobRequisitionItem>()
                .Add(x => x.Qty)
                .Add(x => x.Issued)
                .Add(x => x.InStock)
                .Add(x => x.ID)
                .Add(x => x.Product.Name)
                .Add(x => x.Product.ID)
                .Add(x => x.Style.ID)
                .AddDimensionsColumns(x => x.Dimensions, Dimensions.ColumnsType.Data));

        var changed = false;
        foreach (var jobRequisitionItem in selected)
        {
            // We only want stuff which doesn't have enough total stock allocated, which is the InStock and Issued added together.
            if(!jobRequisitionItem.Qty.IsEffectivelyGreaterThan(jobRequisitionItem.InStock + jobRequisitionItem.Issued))
                continue;
            
            // Filter out ones we've already got.
            if(JobRequiItems.Any(x => x.JobRequiItem.ID == jobRequisitionItem.ID))
            {
                continue;
            }

            var poItem = new PurchaseOrderItem
            {
                Description = jobRequisitionItem.Product.Name,
                Qty = jobRequisitionItem.Qty
            };
            poItem.Product.ID = jobRequisitionItem.Product.ID;
            poItem.Product.Synchronise(jobRequisitionItem.Product);
            poItem.Dimensions.CopyFrom(jobRequisitionItem.Dimensions);
            poItem.Style.ID = jobRequisitionItem.Style.ID;
            poItem.Style.Synchronise(jobRequisitionItem.Style);
            items.Add(poItem);

            JobRequiItems.Add(new JobRequiItemLinking(jobRequisitionItem, poItem));
            changed = true;
        }
        return changed;
    }
}