prs/prs.desktop/Panels/Products/Reservation Management/JobRequisitionPurchasing.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 JobRequisitionPurchasing : 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 JobRequisitionItemPurchaseOrderItem? JobRequisitionItemPurchaseOrderItem { get; set; }

        public PurchaseOrderItem? PurchaseOrderItem { get; set; }

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

        public JobRequiItemLinking(JobRequisitionItem jobRequiItem, JobRequisitionItemPurchaseOrderItem jobRequisitionItemPurchaseOrderItem)
        {
            JobRequiItem = jobRequiItem;
            PurchaseOrderItem = null;
            JobRequisitionItemPurchaseOrderItem = jobRequisitionItemPurchaseOrderItem;
        }
    }

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

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

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

        if(orderID != Guid.Empty)
        {
            var poItems = Client.Query(
                new Filter<JobRequisitionItemPurchaseOrderItem>(x => x.PurchaseOrderItem.PurchaseOrderLink.ID)
                    .IsEqualTo(orderID),
                new Columns<JobRequisitionItemPurchaseOrderItem>(x => x.ID).Add(x => x.JobRequisitionItem.ID))
                .ToObjects<JobRequisitionItemPurchaseOrderItem>();
            foreach (var jriPoi in poItems)
            {
                var jri = new JobRequisitionItem
                {
                    ID = jriPoi.JobRequisitionItem.ID
                };
                JobRequiItems.Add(new JobRequiItemLinking(jri, jriPoi));
            }
        }
    }

    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),
            new Columns<PurchaseOrder>(
                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 toSave = new List<JobRequisitionItemPurchaseOrderItem>();
        foreach(var item in JobRequiItems)
        {
            if(item.PurchaseOrderItem is not null)
            {
                var jriPoi = new JobRequisitionItemPurchaseOrderItem();
                jriPoi.JobRequisitionItem.ID = item.JobRequiItem.ID;
                jriPoi.PurchaseOrderItem.ID = item.PurchaseOrderItem.ID;
                toSave.Add(jriPoi);
                item.JobRequisitionItemPurchaseOrderItem = jriPoi;
            }
        }

        Client.Save(
            toSave,
            "Updated from Job Requi Review Create Purchase Order");
    }

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

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

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

    private bool CreatePOItemsFromRequiItems(IEnumerable<JobRequisitionItem> selected, List<PurchaseOrderItem> items)
    {
        var changed = false;
        foreach (var jobRequisitionItem in selected)
        {
            // We only want not checked or order required.
            if(jobRequisitionItem.Status != JobRequisitionItemStatus.NotChecked &&
                jobRequisitionItem.Status != JobRequisitionItemStatus.OrderRequired)
            {
                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);
            poItem.Job.ID = jobRequisitionItem.Requisition.Job.ID;
            poItem.Job.Synchronise(jobRequisitionItem.Requisition.Job);
            items.Add(poItem);

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