bbwyb/BBWYB.Client/ViewModels/Order/ChoosePurchaseSchemeViewModel.cs

using BBWYB.Client.APIServices;
using BBWYB.Client.Models;
using BBWYB.Client.Views.Order;
using BBWYB.Client.Views.Purchase;
using BBWYB.Common.Extensions;
using BBWYB.Common.Models;
using CommunityToolkit.Mvvm.Input;
using CommunityToolkit.Mvvm.Messaging;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace BBWYB.Client.ViewModels
{
    public class ChoosePurchaseSchemeViewModel : BaseVM
    {
        private PurchaseService purchaseService;
        private GlobalContext globalContext;
        private Order order;
        private bool freeChoice;
        private bool isResponse = true;
        private bool isLoading;

        public IList<PurchaseSchemeSkuGroup> SkuGroup { get; set; }

        public ICommand ConfirmCommand { get; set; }

        public ICommand RefreshCommand { get; set; }


        public bool FreeChoice { get => freeChoice; set { SetProperty(ref freeChoice, value); } }

        public bool IsLoading { get => isLoading; set { SetProperty(ref isLoading, value); } }

        public ChoosePurchaseSchemeViewModel(PurchaseService purchaseService, GlobalContext globalContext)
        {
            this.purchaseService = purchaseService;
            this.globalContext = globalContext;
            this.SkuGroup = new ObservableCollection<PurchaseSchemeSkuGroup>();
            ConfirmCommand = new RelayCommand(Confirm);
            RefreshCommand = new RelayCommand(Refresh);
        }

        protected override void Load()
        {
            IsLoading = true;
            Task.Factory.StartNew(() => LoadScheme());
        }

        public void SetData(Order order)
        {
            this.order = order;
        }

        private void LoadScheme()
        {
            var skuIdList = order.ItemList.Select(osku => osku.SkuId).ToList();
            var response = purchaseService.GetPurchaseSchemeList(skuIdList, shopId: globalContext.User.Shop.ShopId);
            LoadScheme(response);
        }

        private void LoadScheme(ApiResponse<IList<PurchaseSchemeResponse>> response)
        {
            IsLoading = false;
            if (!response.Success)
            {
                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "提示"));
                return;
            }

            if (response.Data == null || response.Data.Count() == 0)
                return;

            var groups = response.Data.GroupBy(s => s.SkuId);
            App.Current.Dispatcher.Invoke(() =>
            {
                foreach (var g in groups)
                {
                    var skuGroup = new PurchaseSchemeSkuGroup()
                    {
                        SkuId = g.Key,
                        SchemeList = g.Select(p => PurchaseScheme.Convert(p)).ToList()
                    };
                    skuGroup.OnSchemeChanged = OnSchemeChanged;
                    SkuGroup.Add(skuGroup);
                }
            });
        }

        private void Confirm()
        {
            if (SkuGroup.Any(s => s.SelectedScheme == null))
            {
                App.Current.Dispatcher.Invoke(() => MessageBox.Show("采购方案选择不完整", "提示"));
                return;
            }

            var schemeList = new List<PurchaseScheme>();
            foreach (var g in SkuGroup)
            {
                schemeList.Add(g.SelectedScheme);
            }

            var p = new OnlinePurchase(order, schemeList);
            p.ShowDialog();
            // GalaSoft.MvvmLight.Messaging.Messenger.Default.Send<object>(null, "ChoosePurchaseScheme_Close");
            WeakReferenceMessenger.Default.Send(new Message_ChoosePurchaseSchemeClose(null));
        }

        private void OnSchemeChanged(PurchaseSchemeSkuGroup skuGroup)
        {
            if (FreeChoice)
                return;
            if (!isResponse)
                return;
            isResponse = false;
            var purchaserId = skuGroup.SelectedScheme.PurchaserId;

            foreach (var otherSkuGroup in SkuGroup)
            {
                if (otherSkuGroup.SkuId == skuGroup.SkuId)
                    continue;

                var samePurchaseScheme = otherSkuGroup.SchemeList.FirstOrDefault(s => s.PurchaserId == purchaserId);
                if (samePurchaseScheme != null)
                    otherSkuGroup.SelectedScheme = samePurchaseScheme;
            }
            isResponse = true;
        }

        public override void Refresh()
        {
            if (SkuGroup.Count() == 0)
                return;
            IsLoading = true;
            var schemeIdList = new List<long>();
            foreach (var group in SkuGroup)
            {
                schemeIdList.AddRange(group.SchemeList.Select(s => s.Id));
                group.SchemeList.Clear();
            }
            SkuGroup.Clear();

            Task.Factory.StartNew(() => purchaseService.RefreshPurchaseScheme(schemeIdList)).ContinueWith(t =>
            {
                var response = t.Result;
                LoadScheme(response);
            });
          
        }
    }
}