IsFriendViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Contacts;
using NeuroAccessMaui.Services.Notification;
using NeuroAccessMaui.UI.Pages.Things.ViewClaimThing;
using System.Collections.ObjectModel;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Events;
using Waher.Networking.XMPP.Provisioning;
using Waher.Persistence;
 
namespace NeuroAccessMaui.UI.Pages.Things.IsFriend
{
    public partial class IsFriendViewModel : XmppViewModel
    {
        private readonly NotificationEvent? @event;
        private readonly IsFriendNavigationArgs? navigationArguments;
 
        public IsFriendViewModel(IsFriendNavigationArgs? Args)
            : base()
        {
            this.navigationArguments = Args;
 
            this.Tags = [];
            this.CallerTags = [];
            this.RuleRanges = [];
 
            if (Args is not null)
            {
                this.@event = Args.Event;
                this.BareJid = Args.BareJid;
                this.FriendlyName = Args.FriendlyName;
                this.RemoteJid = Args.RemoteJid;
                this.RemoteFriendlyName = Args.RemoteFriendlyName;
                this.Key = Args.Key;
                this.ProvisioningService = Args.ProvisioningService;
 
                if (this.FriendlyName == this.BareJid)
                    this.FriendlyName = ServiceRef.Localizer[nameof(AppResources.NotAvailable)];
 
                this.RemoteFriendlyNameAvailable = this.RemoteFriendlyName != this.RemoteJid;
                if (!this.RemoteFriendlyNameAvailable)
                    this.RemoteFriendlyName = ServiceRef.Localizer[nameof(AppResources.NotAvailable)];
            }
        }
 
        public override async Task OnInitializeAsync()
        {
            await base.OnInitializeAsync();
 
            if (this.navigationArguments is not null)
            {
                this.Tags.Clear();
                this.CallerTags.Clear();
 
                ContactInfo Thing = await ContactInfo.FindByBareJid(this.BareJid ?? string.Empty);
                if (Thing?.MetaData is not null)
                {
                    foreach (Property Tag in Thing.MetaData)
                        this.Tags.Add(new HumanReadableTag(Tag));
                }
 
                ContactInfo Caller = await ContactInfo.FindByBareJid(this.RemoteJid ?? string.Empty);
                this.CallerInContactsList = Caller is not null;
                if (Caller?.MetaData is not null)
                {
                    foreach (Property Tag in Caller.MetaData)
                        this.CallerTags.Add(new HumanReadableTag(Tag));
                }
 
                this.RuleRanges.Clear();
                this.RuleRanges.Add(new RuleRangeModel(RuleRange.Caller, ServiceRef.Localizer[nameof(AppResources.CallerOnly)]));
                this.RuleRanges.Add(new RuleRangeModel(RuleRange.Domain, ServiceRef.Localizer[nameof(AppResources.EntireDomain), XmppClient.GetDomain(this.RemoteJid)]));
                this.RuleRanges.Add(new RuleRangeModel(RuleRange.All, ServiceRef.Localizer[nameof(AppResources.Everyone)]));
 
                this.SelectedRuleRangeIndex = 0;
            }
        }
 
        #region Properties
 
        public ObservableCollection<HumanReadableTag> Tags { get; }
 
        public ObservableCollection<HumanReadableTag> CallerTags { get; }
 
        public ObservableCollection<RuleRangeModel> RuleRanges { get; }
 
        [ObservableProperty]
        private string? bareJid;
 
        [ObservableProperty]
        private string? friendlyName;
 
        [ObservableProperty]
        private string? remoteJid;
 
        [ObservableProperty]
        private string? remoteFriendlyName;
 
        [ObservableProperty]
        private bool remoteFriendlyNameAvailable;
 
        [ObservableProperty]
        private string? key;
 
        [ObservableProperty]
        private string? provisioningService;
 
        [ObservableProperty]
        private bool callerInContactsList;
 
        [ObservableProperty]
        private int selectedRuleRangeIndex;
 
        #endregion
 
        [RelayCommand]
        private static Task Click(object obj)
        {
            if (obj is HumanReadableTag Tag)
                return ViewClaimThingViewModel.LabelClicked(Tag.Name, Tag.Value, Tag.LocalizedValue);
            else if (obj is string s)
                return ViewClaimThingViewModel.LabelClicked(string.Empty, s, s);
            else
                return Task.CompletedTask;
        }
 
        [RelayCommand]
        private async Task AddContact()
        {
            if (!this.CallerInContactsList)
            {
                ContactInfo Info = new()
                {
                    BareJid = this.RemoteJid,
                    FriendlyName = (this.RemoteFriendlyNameAvailable ? this.RemoteFriendlyName : this.RemoteJid) ?? string.Empty
                };
 
                await Database.Insert(Info);
 
                this.CallerInContactsList = true;
            }
        }
 
        [RelayCommand]
        private async Task RemoveContact()
        {
            if (this.CallerInContactsList)
            {
                ContactInfo Info = await ContactInfo.FindByBareJid(this.RemoteJid ?? string.Empty);
                if (Info is not null)
                    await Database.Delete(Info);
 
                this.CallerInContactsList = false;
            }
        }
 
        private RuleRange GetRuleRange()
        {
            return this.SelectedRuleRangeIndex switch
            {
                1 => RuleRange.Domain,
                2 => RuleRange.All,
                _ => RuleRange.Caller,
            };
        }
 
        [RelayCommand]
        private void Accept()
        {
            this.Respond(true);
        }
 
        [RelayCommand]
        private void Reject()
        {
            this.Respond(false);
        }
 
        private void Respond(bool Accepts)
        {
            RuleRange Range = this.GetRuleRange();
            FriendshipResolver Resolver = new(this.BareJid ?? string.Empty, this.RemoteJid ?? string.Empty, Range);
 
            ServiceRef.XmppService.IsFriendResponse(this.ProvisioningService ?? ServiceRef.TagProfile.ProvisioningJid ?? string.Empty,
                this.BareJid ?? string.Empty, this.RemoteJid ?? string.Empty, this.Key ?? string.Empty, Accepts, Range,
                this.ResponseHandler, Resolver);
        }
 
        private async Task ResponseHandler(object? Sender, IqResultEventArgs e)
        {
            if (e.Ok)
            {
                if (this.@event is not null)
                    await ServiceRef.NotificationService.DeleteEvents(this.@event);
 
                await ServiceRef.NotificationService.DeleteResolvedEvents((IEventResolver)e.State);
 
                MainThread.BeginInvokeOnMainThread(async () =>
                {
                    await this.GoBack();
                });
            }
            else
            {
                MainThread.BeginInvokeOnMainThread(async () => await ServiceRef.UiService.DisplayException(e.StanzaError ??
                    new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToRespond)])));
            }
        }
 
        [RelayCommand]
        private async Task Ignore()
        {
            if (this.@event is not null)
                await ServiceRef.NotificationService.DeleteEvents(this.@event);
 
            await this.GoBack();
        }
 
    }
}