prs/prs.desktop/Panels/PurchaseOrders/SupplierPurchaseOrderPanel.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using Comal.Classes;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;
using InABox.Wpf;
using Syncfusion.UI.Xaml.Charts;

namespace PRSDesktop;

/// <summary>
///     Interaction logic for SupplierPurchaseOrderPanel.xaml
/// </summary>
public partial class SupplierPurchaseOrderPanel : UserControl, IPanel<PurchaseOrder>
{
    private PurchaseScreenSettings settings;

    public SupplierPurchaseOrderPanel()
    {
        InitializeComponent();
        Orders.HiddenColumns.Add(x => x.SupplierLink.ID);
        Orders.HiddenColumns.Add(x => x.PONumber);
        Orders.HiddenColumns.Add(x => x.SupplierLink.Code);
        Orders.HiddenColumns.Add(x => x.SupplierLink.Name);
        Orders.HiddenColumns.Add(x => x.Description);
        Orders.HiddenColumns.Add(x => x.IssuedDate);
        Orders.HiddenColumns.Add(x => x.IssuedBy.Name);
        Orders.HiddenColumns.Add(x => x.DueDate);
        Orders.HiddenColumns.Add(x => x.ClosedDate);

        /*Orders.OnBeforeSelection += cancel =>
        {
            if (_orders is not null && _orders.Any(x => x.IsChanged()))
            {
                CheckSaved(cancel);
            }
        };*/
        Orders.OnSelectItem += (o, e) =>
        {
            if(SplitPanel.View != DynamicSplitPanelView.Master)
            {
                ReloadOrders();
            }
        };
    }

    public bool IsReady { get; set; }


    public event DataModelUpdateEvent? OnUpdateDataModel;

    public Dictionary<string, object[]> Selected()
    {
        return new Dictionary<string, object[]> { { typeof(PurchaseOrder).EntityName(), Orders.SelectedRows } };
    }


    public void CreateToolbarButtons(IPanelHost host)
    {
        AccountsSetupActions.Standard(host);
        AccountsSetupActions.PurchaseOrderCategories(host);
        PostUtils.CreateToolbarButtons(host,
            () => (DataModel(Selection.Selected) as IDataModel<PurchaseOrder>)!,
            () => Orders.Refresh(false, true),
            true);
    }

    string IDataModelSource.SectionName => SectionName;

    public static string SectionName => "Purchase Orders";

    public DataModel DataModel(Selection selection)
    {
        var ids = Orders.ExtractValues(x => x.ID, selection).ToArray();
        return DataModel(ids);
    }

    public static DataModel DataModel(Guid[] poIDs)
    {
        return new BaseDataModel<PurchaseOrder>(new Filter<PurchaseOrder>(x => x.ID).InList(poIDs));
    }

    public void Refresh()
    {
        if (CheckSaved())
        {
            Orders.Refresh(false, true);
            SetChanged(false);
        }
    }

    public void Setup()
    {
        settings = new UserConfiguration<PurchaseScreenSettings>().Load();
        
        SplitPanel.View = settings.ViewType == ScreenViewType.Register ? DynamicSplitPanelView.Master :
            settings.ViewType == ScreenViewType.Details ? DynamicSplitPanelView.Detail : DynamicSplitPanelView.Combined;
        SplitPanel.AnchorWidth = Math.Max(20,settings.AnchorWidth);
        
        Orders.ColumnsTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
        Orders.Refresh(true, false);
        
        PurchaseOrder.SetLayoutType<VerticalDynamicEditorGridLayout>();
    }

    private void CheckSaved(CancelEventArgs cancel)
    {
        if(_orders is null || !_orders.Any(x => x.IsChanged()))
        {
            return;
        }
        var result = MessageBox.Show("You have an unsaved Purchase Order; do you wish to save these changes?", "Save Changes?", MessageBoxButton.YesNoCancel);
        if (result == MessageBoxResult.Yes)
        {
            PurchaseOrder.SaveItem(cancel);
            if (!cancel.Cancel)
            {
                MessageBox.Show("Purchase Order saved.");
            }
        }
        else if (result == MessageBoxResult.Cancel)
        {
            cancel.Cancel = true;
        }
    }
    
    private bool CheckSaved()
    {
        var cancel = new CancelEventArgs();
        CheckSaved(cancel);
        return !cancel.Cancel;
    }

    public void Shutdown(CancelEventArgs? cancel)
    {
        if(cancel is not null)
        {
            CheckSaved(cancel);
        }
    }

    public void Heartbeat(TimeSpan time)
    {
    }

    // private void LoadOrder(CoreRow row)
    // {
    //     Number.Text = row == null ? "" : row.Get<PurchaseOrder, string>(x => x.PONumber);
    //
    //     SupplierCode.Text = row == null ? "" : row.Get<PurchaseOrder, string>(x => x.SupplierLink.Code);
    //     SupplierName.Text = row == null ? "" : row.Get<PurchaseOrder, string>(x => x.SupplierLink.Name);
    //
    //     Description.Text = row == null ? "" : row.Get<PurchaseOrder, string>(x => x.Description);
    //
    //     Issued.Text = row == null ? "" : CheckDate(row.Get<PurchaseOrder, DateTime>(x => x.IssuedDate));
    //     IssuedBy.Text = row == null ? "" : row.Get<PurchaseOrder, string>(x => x.IssuedBy.Name);
    //
    //     DueDate.Text = row == null ? "" : CheckDate(row.Get<PurchaseOrder, DateTime>(x => x.DueDate));
    //     ClosedDate.Text = row == null ? "" : CheckDate(row.Get<PurchaseOrder, DateTime>(x => x.ClosedDate));
    // }

    // private string CheckDate(DateTime date)
    // {
    //     return date.IsEmpty() ? "" : date.ToShortDateString();
    // }
    //
    // private void LoadLookups<T>(MultiQuery query, List<Tuple<Guid, string>> lookups, Expression<Func<T, string>> display) where T : Entity
    // {
    //     var table = query.Get<T>();
    //     foreach (var row in table.Rows)
    //         lookups.Add(new Tuple<Guid, string>(row.Get<T, Guid>(c => c.ID), row.Get(display)));
    // }
    //
    // private void CategoryList_SelectionChanged(object sender, SelectionChangedEventArgs e)
    // {
    //     if (!IsReady)
    //         return;
    //
    //     Orders.SelectedCategory = (Guid)CategoryList.SelectedValue;
    //
    //     settings.SelectedCategory = Orders.SelectedCategory;
    //     new UserConfiguration<PurchaseScreenSettings>().Save(settings);
    //
    //     Refresh();
    // }
    //
    // private void StatusList_SelectionChanged(object sender, SelectionChangedEventArgs e)
    // {
    //     if (!IsReady)
    //         return;
    //
    //     Orders.ShowAll = StatusList.SelectedIndex == 1;
    //
    //     settings.ShowAll = Orders.ShowAll;
    //     new UserConfiguration<PurchaseScreenSettings>().Save(settings);
    //
    //     Refresh();
    // }
    //
    // private void Search_KeyUp(object sender, KeyEventArgs e)
    // {
    // }
    //
    private void SplitPanel_OnChanged(object sender, DynamicSplitPanelSettings e)
    {
        settings.ViewType = SplitPanel.View == DynamicSplitPanelView.Master ? ScreenViewType.Register :
            SplitPanel.View == DynamicSplitPanelView.Detail ? ScreenViewType.Details : ScreenViewType.Combined;
        settings.AnchorWidth = SplitPanel.AnchorWidth;

        var newTag = settings.ViewType == ScreenViewType.Register ? settings.ViewType.ToString() : "";
        if (Orders.ColumnsTag != newTag)
        {
            Orders.ColumnsTag = newTag;
            Orders.Refresh(true, true);
        }

        new UserConfiguration<PurchaseScreenSettings>().Save(settings);
    }
    
    private PurchaseOrder[]? _orders = null;
    
    private void ReloadOrders()
    {
        if (Orders.SelectedRows?.Any() == true)
        {
            _orders = Orders.LoadOrders(Orders.SelectedRows);
            Orders.InitialiseEditorForm(PurchaseOrder, _orders);
            PurchaseOrder.Visibility = Visibility.Visible;
        }
        else
        {
            _orders = null;
            PurchaseOrder.Visibility = Visibility.Hidden;
        }
    }

    private void SetChanged(bool changed)
    {
        bChanged = changed;
        Orders.IsEnabled = !changed;
        PurchaseOrder.HideButtons = !changed;
    }

    private void PurchaseOrder_OnOK()
    {
        using (new WaitCursor())
        {
            var cancel = new System.ComponentModel.CancelEventArgs();
            PurchaseOrder.SaveItem(cancel);
            Orders.Refresh(false, true);
            if (!cancel.Cancel)
            {
                ReloadOrders();
                SetChanged(false);
            }
        }
    }

    private void PurchaseOrder_OnCancel()
    {
        ReloadOrders();
        SetChanged(false);
    }

    private bool bChanged = false;
    private void PurchaseOrder_OnOnChanged(object? sender, EventArgs e)
    {
        SetChanged(true);
    }
}