TokenItem.cs

using System.Xml;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Kyc.ViewModels;
using NeuroAccessMaui.Services.Notification;
using NeuroAccessMaui.Services.UI;
using NeuroAccessMaui.UI.Pages.Wallet.TokenDetails;
using NeuroFeatures;
using NeuroFeatures.Tags;
using SkiaSharp;
using Waher.Content;
using Waher.Networking.XMPP.Contracts;
using Waher.Security;
 
namespace NeuroAccessMaui.UI.Pages.Wallet.MyWallet.ObjectModels
{
    public partial class TokenItem : ObservableObject, IUniqueItem
    {
        private readonly Token token;
        private readonly TaskCompletionSource<TokenItem?>? selected;
        private bool? @new;
        private int nrEvents;
        private NotificationEvent[] notificationEvents;
 
        public TokenItem(Token Token, NotificationEvent[] NotificationEvents)
            : this(Token, null, NotificationEvents)
        {
        }
 
        public TokenItem(Token Token, TaskCompletionSource<TokenItem?>? Selected, NotificationEvent[] NotificationEvents)
        {
            this.token = Token;
            this.selected = Selected;
            this.notificationEvents = NotificationEvents;
 
            if (this.Glyph is not null && this.GlyphContentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
            {
                this.GlyphImage = ImageSource.FromStream(() => new MemoryStream(this.Glyph));
                this.HasGlyphImage = true;
 
                double s = 32.0 / this.token.GlyphWidth;
                double s2 = 32.0 / this.token.GlyphHeight;
 
                if (s2 < s)
                    s = s2;
                else if (s > 1)
                    s = 1;
 
                this.GlyphWidth = (int)(this.token.GlyphWidth * s + 0.5);
                this.GlyphHeight = (int)(this.token.GlyphHeight * s + 0.5);
            }
            else
            {
                this.GlyphImage = null;
                this.HasGlyphImage = false;
                this.GlyphWidth = 0;
                this.GlyphHeight = 0;
            }
        }
 
        public Token Token => this.token;
 
        public string UniqueName => this.token.TokenId;
 
        public DateTime Created => this.token.Created;
 
        public DateTime Updated => this.token.Updated;
 
        public DateTime Expires => this.token.Expires;
 
        public Duration? ArchiveRequired => this.token.ArchiveRequired;
 
        public Duration? ArchiveOptional => this.token.ArchiveOptional;
 
        public DateTime SignatureTimestamp => this.token.SignatureTimestamp;
 
        public byte[] Signature => this.token.Signature;
 
        public byte[] DefinitionSchemaDigest => this.token.DefinitionSchemaDigest;
 
        public HashFunction DefinitionSchemaHashFunction => this.token.DefinitionSchemaHashFunction;
 
        public bool CreatorCanDestroy => this.token.CreatorCanDestroy;
 
        public bool OwnerCanDestroyBatch => this.token.OwnerCanDestroyBatch;
 
        public bool OwnerCanDestroyIndividual => this.token.OwnerCanDestroyIndividual;
 
        public bool CertifierCanDestroy => this.token.CertifierCanDestroy;
 
        public string FriendlyName => this.token.FriendlyName;
 
        public string Category => this.token.Category;
 
        public string Description => this.token.Description;
 
        public byte[] Glyph => this.token.Glyph;
 
        public string GlyphContentType => this.token.GlyphContentType;
 
        public int Ordinal => this.token.Ordinal;
 
        public decimal Value => this.token.Value;
 
        public string[] Witness => this.token.Witness;
 
        public string[] CertifierJids => this.token.CertifierJids;
 
        public string[] Certifier => this.token.Certifier;
 
        public TokenIdMethod TokenIdMethod => this.token.TokenIdMethod;
 
        public string TokenId => this.token.TokenId;
 
        public string ShortTokenId => this.token.ShortId;
 
        public ContractVisibility Visibility => this.token.Visibility;
 
        public string Creator => this.token.Creator;
 
        public string CreatorJid => this.token.CreatorJid;
 
        public string Owner => this.token.Owner;
 
        public int BatchSize => this.token.BatchSize;
 
        public string TrustProvider => this.token.TrustProvider;
 
        public string OwnerJid => this.token.OwnerJid;
 
        public string Currency => this.token.Currency;
 
        public string Reference => this.token.Reference;
 
        public string Definition => this.token.Definition;
 
        public string DefinitionNamespace => this.token.DefinitionNamespace;
 
        public string CreationContract => this.token.CreationContract;
 
        public string OwnershipContract => this.token.OwnershipContract;
 
        public string[] Valuator => this.token.Valuator;
 
        public string[] Assessor => this.token.Assessor;
 
        public string TrustProviderJid => this.token.TrustProviderJid;
 
        public TokenTag[] Tags => this.token.Tags;
 
        public bool HasStateMachine => this.token.HasStateMachine;
 
        public bool HasEmbeddedLayout => this.token.HasEmbeddedLayout;
 
        public XmlElement EmbeddedLayoutDefinition => this.token.EmbeddedLayoutDefinition;
 
        [ObservableProperty]
        private ImageSource? glyphImage;
 
        [ObservableProperty]
        private bool hasGlyphImage;
 
        [ObservableProperty]
        private int glyphWidth;
 
        [ObservableProperty]
        private int glyphHeight;
 
        public NotificationEvent[] NotificationEvents => this.notificationEvents;
 
        public int NrEvents
        {
            get
            {
                this.CheckEvents();
 
                return this.nrEvents;
            }
        }
 
        public bool New
        {
            get
            {
                this.CheckEvents();
 
                return this.@new ?? false;
            }
        }
 
        private void CheckEvents()
        {
            if (!this.@new.HasValue)
            {
                this.nrEvents = this.notificationEvents.Length;
                this.@new = this.nrEvents > 0;
 
                if (this.@new.Value)
                {
                    NotificationEvent[] ToDelete = this.notificationEvents;
 
                    this.notificationEvents = [];
 
                    Task.Run(() => ServiceRef.NotificationService.DeleteEvents(ToDelete));
                }
            }
        }
 
        public async Task<ImageSource?> RenderEmbeddedLayout()
        {
            if (!this.Token.HasEmbeddedLayout)
                return null;
 
            SkiaSharp.SKImage Img = await this.Token.RenderEmbeddedLayout();
 
            return ImageSource.FromStream(() =>
            {
                SKData Data = Img.Encode(SKEncodedImageFormat.Png, 100);
                return Data.AsStream();
            });
        }
 
        [RelayCommand]
        private async Task Clicked()
        {
            if (this.selected is null)
            {
                TokenDetailsNavigationArgs Args = new(this);
 
                await ServiceRef.NavigationService.GoToAsync(nameof(TokenDetailsPage), Args, BackMethod.Pop);
            }
            else
            {
                this.selected.TrySetResult(this);
                await ServiceRef.UiService.GoBackAsync();
            }
        }
    }
}