prs/prs.desktop/Panels/PurchaseOrders/SupplierPurchaseOrders.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Imaging;
using Comal.Classes;
using InABox.Clients;
using InABox.Configuration;
using InABox.Core;
using InABox.DynamicGrid;
using InABox.WPF;

namespace PRSDesktop;


public class SupplierPurchaseOrdersSettings : IUserConfigurationSettings
{
    [Obsolete]
    private CoreFilterDefinition? _currentFilter;

    [Obsolete]
    public CoreFilterDefinition? CurrentFilter
    {
        get => _currentFilter;
        set
        {
            if (value is not null)
            {
                Filters = new DynamicGridSelectedFilterSettings(new List<ICoreFilterDefinition> { value }, false, null);
            }
        }
    }

    public DynamicGridSelectedFilterSettings Filters { get; set; } = new();
}

public class SupplierPurchaseOrders : DynamicDataGrid<PurchaseOrder>
{
    private readonly Button close;
    
    private SupplierPurchaseOrdersSettings _settings;

    public BitmapImage _truck = PRSDesktop.Resources.truck.AsBitmapImage();
    public BitmapImage _tick = PRSDesktop.Resources.tick.AsBitmapImage();
    public BitmapImage _warning = PRSDesktop.Resources.warning.AsBitmapImage();

    public SupplierPurchaseOrders()
    {
        _settings = new UserConfiguration<SupplierPurchaseOrdersSettings>().Load();
        FilterComponent.SetSettings(_settings.Filters, false);
        FilterComponent.OnFiltersSelected += FilterComponent_OnFilterSelected;

        OnEditorValueChanged += SupplierPurchaseOrders_OnEditorValueChanged;
        OnCustomiseEditor += SupplierPurchaseOrders_OnCustomiseEditor;
        
        HiddenColumns.Add(x => x.IssuedDate);
        HiddenColumns.Add(x => x.ClosedDate);
        HiddenColumns.Add(x => x.Balance);
        HiddenColumns.Add(x => x.Unreceived);
        HiddenColumns.Add(x => x.Received);
        
        ActionColumns.Add(new DynamicImageColumn(IssuedStatus));
        ActionColumns.Add(new DynamicImageColumn(ReceivedStatus));
        
        PostUtils.AddPostColumn(this);

        close = AddButton("Close Order", null, CloseOrder);
        close.IsEnabled = false;
    }

    private BitmapImage? IssuedStatus(CoreRow? row)
    {
        return row == null
            ? _tick
            : !row.Get<PurchaseOrder, DateTime>(x => x.IssuedDate).IsEmpty()
                ? _tick
                : null;
    }

    private BitmapImage? ReceivedStatus(CoreRow? row)
    {
        return row == null
            ? _truck
            : row.Get<PurchaseOrder, double>(x => x.Unreceived).IsEffectivelyEqual(0.0)
                ? _tick
                : !row.Get<PurchaseOrder, double>(x => x.Received).IsEffectivelyEqual(0.0)
                    ? _warning
                    : null;
    }

    protected override void DoReconfigure(DynamicGridOptions options)
    {
        base.DoReconfigure(options);
        options.RecordCount = true;
        options.FilterRows = true;
        options.SelectColumns = true;
    }

    private void SupplierPurchaseOrders_OnCustomiseEditor(IDynamicEditorForm sender, PurchaseOrder[]? items, DynamicGridColumn column, BaseEditor editor)
    {
        if(column.ColumnName == nameof(PurchaseOrder.ClosedDate))
        {
            editor.Editable = Security.CanEdit<PurchaseOrder>() && Security.IsAllowed<CanOpenAndClosePurchaseOrders>()
                ? Editable.Enabled : Editable.Disabled;
        }
    }

    protected override void DoReconfigureEditors(DynamicEditorGrid grid, PurchaseOrder[] items)
    {
        base.DoReconfigureEditors(grid, items);

        var closedEditor = grid.FindEditor(nameof(PurchaseOrder.ClosedDate));
        if(closedEditor is not null)
        {
            closedEditor.IsEnabled = Security.CanEdit<PurchaseOrder>() && Security.IsAllowed<CanOpenAndClosePurchaseOrders>();
        }
    }

    protected override void BeforeLoad(IDynamicEditorForm form, PurchaseOrder[] items)
    {
        base.BeforeLoad(form, items);

        foreach (var page in form.Pages ?? Enumerable.Empty<IDynamicEditorPage>())
        {
            page.ReadOnly = items.Any(x => !x.ClosedDate.IsEmpty());
        }
    }

    private Dictionary<string, object?> SupplierPurchaseOrders_OnEditorValueChanged(IDynamicEditorForm sender, string name, object value)
    {
        var result = new Dictionary<string, object?>();
        if(name == nameof(PurchaseOrder.ClosedDate) && value is DateTime closed)
        {
            foreach (var page in sender.Pages ?? Enumerable.Empty<IDynamicEditorPage>())
            {
                page.ReadOnly = !closed.IsEmpty();
            }
        }
        //try
        //{               
        //    var form = sender as DynamicEditorForm;
        //    var itemspage = form?.Pages.FirstOrDefault(x => x is DynamicOneToManyGrid<PurchaseOrder, PurchaseOrderItem>) as DynamicOneToManyGrid<PurchaseOrder, PurchaseOrderItem>;
        //    if ((itemspage == null) || (itemspage.Items.Count == 0))
        //        return result;

        //    if (name.Equals("DueDate") && (MessageBox.Show("Update Due Date on existing items?", "Alert", MessageBoxButton.YesNo) == MessageBoxResult.Yes))
        //    {
        //        foreach (var item in itemspage.Items)
        //            item.DueDate = Convert.ToDateTime(value);
        //        itemspage.Refresh(false, true);
        //    }
        //    else if (name.Equals("SupplierLink.ID") &&
        //             (MessageBox.Show("Update Supplier Pricing to existihg items?", "Alert", MessageBoxButton.YesNo) == MessageBoxResult.Yes))
        //    {
        //        PurchaseOrder.UpdateCosts(itemspage.Items, (Guid)value, null);
        //        // var productids = itemspage.Items.Where(x => x.Product.ID != Guid.Empty).Select(x => x.Product.ID).ToArray();
        //        // MultiQuery query = new MultiQuery();
        //        // query.Add(
        //        //     new Filter<SupplierProduct>(x=>x.SupplierLink.ID).IsEqualTo(value).And(x=>x.ProductLink.ID).InList(productids),
        //        //     new Columns<SupplierProduct>(x=>x.ProductLink.ID).Add(x=>x.Job.ID).Add(x=>x.CostPrice)
        //        // );
        //        // query.Add(
        //        //     new Filter<Product>(x=>x.ID).InList(productids),
        //        //     new Columns<Product>(x=>x.ID).Add(x=>x.NettCost)
        //        // );
        //        // query.Query();
        //        //
        //        // foreach (var item in itemspage.Items)
        //        // {
        //        //     CoreRow? row = query.Get<SupplierProduct>()?.Rows.FirstOrDefault(r =>
        //        //         (r.Get<SupplierProduct, Guid>(c => c.ProductLink.ID) == item.Product.ID)
        //        //         && (r.Get<SupplierProduct, Guid>(c => c.Job.ID) == item.Job.ID)
        //        //     );
        //        //     if (row == null)
        //        //         row = query.Get<SupplierProduct>()?.Rows.FirstOrDefault(r =>
        //        //             (r.Get<SupplierProduct, Guid>(c => c.ProductLink.ID) == item.Product.ID)
        //        //             && (r.Get<SupplierProduct, Guid>(c => c.Job.ID) == Guid.Empty)
        //        //         );
        //        //     if (row != null)
        //        //         item.Cost = row.Get<SupplierProduct, double>(c => c.CostPrice);
        //        //     else
        //        //     {
        //        //         row = query.Get<Product>()?.Rows.FirstOrDefault(r =>
        //        //             (r.Get<Product, Guid>(c => c.ID) == item.Product.ID)
        //        //         );
        //        //         if (row != null)
        //        //             item.Cost = row.Get<Product, double>(c => c.NettCost);
        //        //     }
        //        //
        //        // }

        //        itemspage.Refresh(false, true);
        //    }
        //}
        //catch
        //{ }
        return result;
        
    }

    // private List<SupplierProduct> GetSupplierProducts(object value)
    // {
    //     List<SupplierProduct> supplierProducts = new List<SupplierProduct>();
    //     CoreTable supplierProductstable = new Client<SupplierProduct>().Query(new Filter<SupplierProduct>(x => x.SupplierLink.ID).IsEqualTo(Guid.Parse(value.ToString())),
    //     new Columns<SupplierProduct>(
    //     x => x.ID,
    //     x => x.SupplierLink.ID,
    //     x => x.ProductLink.ID,
    //     x => x.Job.ID,
    //     x => x.TradePrice));
    //     if (supplierProductstable.Rows.Any())
    //     {
    //         foreach (CoreRow row in supplierProductstable.Rows)
    //         {
    //             SupplierProduct supplierProduct = row.ToObject<SupplierProduct>();
    //             supplierProducts.Add(supplierProduct);
    //         }
    //     }
    //     return supplierProducts;
    // }
    
    protected override void SelectItems(CoreRow[]? rows)
    {
        close.IsEnabled = rows != null && rows.Any(r =>
            r.Get<PurchaseOrder, DateTime>(c => c.ClosedDate).IsEmpty() && r.Get<PurchaseOrder, double>(x => x.Balance).Equals(0.0F));
        base.SelectItems(rows);
    }

    private bool CloseOrder(Button arg1, CoreRow[] arg2)
    {
        var orders = new List<PurchaseOrder>();
        foreach (var row in arg2)
        {
            var order = row.ToObject<PurchaseOrder>();
            order.ClosedDate = DateTime.Now;
            orders.Add(order);
        }

        new Client<PurchaseOrder>().Save(orders, "Marking Order as Closed");
        return true;
    }
    
    public PurchaseOrder[] LoadOrders(CoreRow[] rows)
    {
        return LoadItems(rows);
    }
    
    private void FilterComponent_OnFilterSelected(DynamicGridSelectedFilterSettings settings)
    {
        _settings.Filters = settings;
        new UserConfiguration<SupplierPurchaseOrdersSettings>().Save(_settings);
    }
}