MyTokensViewModel.cs

using NeuroAccessMaui.UI.Pages.Wallet.MyWallet.ObjectModels;
using NeuroAccessMaui.Services.Notification;
using NeuroFeatures;
using System.Collections.ObjectModel;
using Waher.Persistence;
using NeuroAccessMaui.Services;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
 
namespace NeuroAccessMaui.UI.Pages.Wallet.MyTokens
{
    public partial class MyTokensViewModel(MyTokensNavigationArgs? Args) : XmppViewModel()
    {
        private readonly MyTokensNavigationArgs? navigationArgs = Args;
 
        protected override async Task OnInitialize()
        {
            await base.OnInitialize();
 
            try
            {
                TokensEventArgs e = await ServiceRef.XmppService.GetNeuroFeatures(0, Constants.BatchSizes.TokenBatchSize);
                SortedDictionary<CaseInsensitiveString, NotificationEvent[]> EventsByCateogy = ServiceRef.NotificationService.GetEventsByCategory(NotificationEventType.Wallet);
 
                MainThread.BeginInvokeOnMainThread(() =>
                {
                    if (e.Ok)
                    {
                        this.Tokens.Clear();
 
                        if (e.Tokens is not null)
                        {
                            foreach (Token Token in e.Tokens)
                            {
                                if (!EventsByCateogy.TryGetValue(Token.TokenId, out NotificationEvent[]? Events))
                                    Events = [];
 
                                this.Tokens.Add(new TokenItem(Token, this.navigationArgs?.TokenItemProvider, Events));
                            }
 
                            this.HasTokens = true;
                            this.HasMoreTokens = e.Tokens.Length == Constants.BatchSizes.TokenBatchSize;
                        }
                        else
                            this.HasTokens = false;
                    }
                    else
                        this.HasTokens = false;
                });
 
                ServiceRef.XmppService.NeuroFeatureAdded += this.Wallet_TokenAdded;
                ServiceRef.XmppService.NeuroFeatureRemoved += this.Wallet_TokenRemoved;
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        protected override Task OnDispose()
        {
            ServiceRef.XmppService.NeuroFeatureAdded -= this.Wallet_TokenAdded;
            ServiceRef.XmppService.NeuroFeatureRemoved -= this.Wallet_TokenRemoved;
 
            if (this.navigationArgs?.TokenItemProvider is TaskCompletionSource<TokenItem?> TaskSource)
                TaskSource.TrySetResult(null);
 
            return base.OnDispose();
        }
 
        private Task Wallet_TokenAdded(object? Sender, TokenEventArgs e)
        {
            if (!ServiceRef.NotificationService.TryGetNotificationEvents(NotificationEventType.Wallet, e.Token.TokenId, out NotificationEvent[]? Events))
                Events = [];
 
            MainThread.BeginInvokeOnMainThread(() =>
            {
                TokenItem Item = new(e.Token, this.navigationArgs?.TokenItemProvider, Events);
 
                if (this.Tokens.Count == 0)
                    this.Tokens.Add(Item);
                else
                    this.Tokens.Insert(0, Item);
            });
 
            return Task.CompletedTask;
        }
 
        private Task Wallet_TokenRemoved(object? Sender, TokenEventArgs e)
        {
            MainThread.BeginInvokeOnMainThread(() =>
            {
                int i, c = this.Tokens.Count;
 
                for (i = 0; i < c; i++)
                {
                    TokenItem Item = this.Tokens[i];
 
                    if (Item.TokenId == e.Token.TokenId)
                    {
                        this.Tokens.RemoveAt(i);
                        break;
                    }
                }
            });
 
            return Task.CompletedTask;
        }
 
        #region Properties
 
        [ObservableProperty]
        private bool hasTokens;
 
        [ObservableProperty]
        private bool hasMoreTokens;
 
        public ObservableCollection<TokenItem> Tokens { get; } = [];
 
        #endregion
 
        [RelayCommand]
        private Task Back()
        {
            return this.GoBack();
        }
 
        public override Task GoBack()
        {
            this.navigationArgs?.TokenItemProvider.TrySetResult(null);
            return base.GoBack();
        }
 
        [RelayCommand]
        private async Task LoadMoreTokens()
        {
            if (this.HasMoreTokens)
            {
                this.HasMoreTokens = false; // So multiple requests are not made while scrolling.
 
                try
                {
                    TokensEventArgs e = await ServiceRef.XmppService.GetNeuroFeatures(this.Tokens.Count, Constants.BatchSizes.TokenBatchSize);
                    SortedDictionary<CaseInsensitiveString, NotificationEvent[]> EventsByCateogy = ServiceRef.NotificationService.GetEventsByCategory(NotificationEventType.Wallet);
 
                    MainThread.BeginInvokeOnMainThread(() =>
                    {
                        if (e.Ok)
                        {
                            if (e.Tokens is not null)
                            {
                                foreach (Token Token in e.Tokens)
                                {
                                    if (!EventsByCateogy.TryGetValue(Token.TokenId, out NotificationEvent[]? Events))
                                        Events = [];
 
                                    this.Tokens.Add(new TokenItem(Token, Events));
                                }
 
                                this.HasMoreTokens = e.Tokens.Length == Constants.BatchSizes.TokenBatchSize;
                            }
                        }
                    });
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                }
            }
        }
 
    }
}