prs/prs.mobile.new/PRS.Mobile/Modules/Purchases/PurchaseOrderListView.xaml.cs

using System;
using System.Threading.Tasks;
using InABox.Configuration;
using InABox.Core;
using InABox.Mobile;
using Xamarin.Forms;
using Xamarin.Forms.Xaml;

namespace PRS.Mobile
{
    
    public class PurchaseOrderModuleSettings : ILocalConfigurationSettings
    {
        public String FilterName { get; set; }
    }
    
    // public class PurchaseOrderFilterConfigurationEventArgs : EventArgs
    // {
    //     public CoreFilterDefinitions Filters { get; private set; }
    //
    //     public String SelectedFilter { get; private set; }
    //     
    //     public PurchaseOrderFilterConfigurationEventArgs(CoreFilterDefinitions filters, String selectedfilter)
    //     {
    //         Filters = filters;
    //         SelectedFilter = selectedfilter;
    //     }
    // }
    
    // public delegate void PurchaseOrderFilterConfigurationEvent(object sender,
    //     PurchaseOrderFilterConfigurationEventArgs args);
    
    public class PurchaseOrderSelectedEventArgs : EventArgs
    {
        public PurchaseOrderShell Order { get; private set; }

        public PurchaseOrderSelectedEventArgs(PurchaseOrderShell order)
        {
            Order = order;
        }
    }
    
    public delegate void PurchaseOrderSelectedEvent(object sender, PurchaseOrderSelectedEventArgs args);

    public class PurchaseOrderStatusConverter : AbstractConverter<PurchaseOrderShell, String>
    {
        protected override string? Convert(PurchaseOrderShell? value, object? parameter = null)
        {
            return value == null
                ? string.Empty
                : !value.CancelledDate.IsEmpty()
                    ? "Cancelled"
                    : !value.ClosedDate.IsEmpty()
                        ? "Closed"
                        : !value.IssuedDate.IsEmpty()
                            ? !value.Unreceived.IsEffectivelyEqual(0.0)
                                ? !value.Received.IsEffectivelyEqual(0.0)
                                    ? "Backorder"
                                    : "Issued"
                                : "Received"
                            : "Draft";
        }
    }
    
    
    [XamlCompilation(XamlCompilationOptions.Compile)]
    public partial class PurchaseOrderListView
    {
        
        private PurchaseOrderModuleSettings _settings;
        
        //public event PurchaseOrderFilterConfigurationEvent ConfigureFilters;
        public event PurchaseOrderSelectedEvent PurchaseOrderSelected;

        private CoreFilterDefinitions _filters;
        public CoreFilterDefinitions Filters => _filters;

        public String CurrentFilter => _settings?.FilterName ?? string.Empty;
        
        public PurchaseOrderListView()
        {
            
            var _setup = new []
            {
                Task.Run(() => { _settings = new LocalConfiguration<PurchaseOrderModuleSettings>().Load(); }),
                Task.Run(() => { _filters = App.Data.PurchaseOrders.AvailableFilters(); }),

            };
            InitializeComponent();
            
            Task.WaitAll(_setup);
            //ConfigureFilters?.Invoke(this,new PurchaseOrderFilterConfigurationEventArgs(_filters, _settings.FilterName));
            
            RefreshData(false,true);
        }

        public void SelectFilter(string filter)
        {
            _settings.FilterName = filter;
            new LocalConfiguration<PurchaseOrderModuleSettings>().Save(_settings);
            RefreshData(true, false);
        }

        private void RefreshData(bool force, bool async)
        {
            App.Data.PurchaseOrders.SelectFilter(_settings.FilterName);
            if (async)
                App.Data.PurchaseOrders.Refresh(force, () => Dispatcher.BeginInvokeOnMainThread(Refresh));
            else
            {
                App.Data.PurchaseOrders.Refresh(force);
                Refresh();
            }
        }

        private void Refresh()
        {
            App.Data.PurchaseOrders.Search(FilterShell);
            _list.ItemsSource ??= App.Data.PurchaseOrders.Items;
        }

        private String _currentFilter;

        private bool FilterShell(PurchaseOrderShell shell)
        {
            try
            {
                return String.IsNullOrWhiteSpace(_currentFilter)
                       || (shell.SupplierName?.ToUpper().Contains(_currentFilter) == true)
                       || (shell.Notes?.ToUpper().Contains(_currentFilter) == true)
                       || (shell.PONumber?.ToUpper().Contains(_currentFilter) == true);
            }
            catch (Exception)
            {
                return true;
            }

        }
        
        private void _search_OnTextChanged(object sender, MobileSearchBarTextChangedArgs args)
        {
            _currentFilter = args.Text.ToUpper();
            Refresh();
        }

        private void _list_ItemTapped(object sender, EventArgs e)
        {
            if ((sender as Frame)?.BindingContext is PurchaseOrderShell shell)
                PurchaseOrderSelected?.Invoke(this,new PurchaseOrderSelectedEventArgs(shell));
        }

        private void _list_OnRefreshRequested(object sender, MobileListRefreshEventArgs args)
        {
            RefreshData(true,false);
        }
    }
}