ContactInfoModel.cs

using System.ComponentModel;
using System.Text;
using System.Windows.Input;
using Mopups.Services;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Contacts;
using NeuroAccessMaui.Services.Notification;
using NeuroAccessMaui.UI.Popups.Xmpp.RemoveSubscription;
using NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
 
namespace NeuroAccessMaui.UI.Pages.Contacts.MyContacts
{
    public class ContactInfoModel : INotifyPropertyChanged, IUniqueItem
    {
        private readonly ContactInfo? contact;
        private NotificationEvent[] events;
 
        private readonly ICommand toggleSubscriptionCommand;
 
        public ContactInfoModel(ContactInfo? Contact, params NotificationEvent[] Events)
        {
            this.contact = Contact;
            this.events = Events;
 
            this.toggleSubscriptionCommand = new Command(async () => await this.ToggleSubscription(), () => this.CanToggleSubscription());
        }
 
        public string UniqueName => this.contact?.ThingNotificationCategoryKey ?? string.Empty;
 
        public ContactInfo? Contact => this.contact;
 
        public CaseInsensitiveString? BareJid => this.contact?.BareJid;
 
        public CaseInsensitiveString? LegalId => this.contact?.LegalId;
 
        public LegalIdentity? LegalIdentity => this.contact?.LegalIdentity;
 
        public string? FriendlyName => this.contact?.FriendlyName;
 
        public string? SourceId => this.contact?.SourceId;
 
        public string? Partition => this.contact?.Partition;
 
        public string? NodeId => this.contact?.NodeId;
 
        public CaseInsensitiveString? RegistryJid => this.contact?.RegistryJid;
 
        public bool? SubcribeTo => this.contact?.SubscribeTo;
 
        public bool? AllowSubscriptionFrom => this.contact?.AllowSubscriptionFrom;
 
        public bool? IsThing => this.contact?.IsThing;
 
        public bool? Owner => this.contact?.Owner;
 
        public Property[]? MetaData => this.contact?.MetaData;
 
        public NotificationEvent[] Events => this.events;
 
        public bool HasEvents => this.events is not null && this.events.Length > 0;
 
        public int NrEvents => this.events?.Length ?? 0;
 
        public Color ConnectionColor
        {
            get
            {
                if (string.IsNullOrEmpty(this.contact?.BareJid))
                    return Colors.Transparent;
 
                RosterItem? Item = null;
                try
                {
                    Item = ServiceRef.XmppService.GetRosterItem(this.contact?.BareJid);
                }
                catch (Exception)
                {
                    return Colors.Transparent;
                }
                if (Item is null)
                    return Colors.Transparent;
 
                if (Item.State != SubscriptionState.To && Item.State != SubscriptionState.Both)
                    return Colors.Transparent;
 
                if (!Item.HasLastPresence)
                    return Colors.LightSalmon;
 
                return Item.LastPresence.Availability switch
                {
                    Availability.Online or Availability.Chat => Colors.LightGreen,
                    Availability.Away or Availability.ExtendedAway => Colors.LightYellow,
                    _ => Colors.LightSalmon,
                };
            }
        }
 
        public ICommand ToggleSubscriptionCommand => this.toggleSubscriptionCommand;
 
        public bool CanToggleSubscription()
        {
            return !string.IsNullOrEmpty(this.contact?.BareJid);
        }
 
        public async Task ToggleSubscription()
        {
            if (string.IsNullOrEmpty(this.contact?.BareJid))
                return;
 
            RosterItem? Item = null;
            try
            {
                Item = ServiceRef.XmppService.GetRosterItem(this.contact?.BareJid);
            }
            catch
            {
                await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.Error)], ServiceRef.Localizer[nameof(AppResources.NetworkSeemsToBeMissing)], ServiceRef.Localizer[nameof(AppResources.Ok)]);
                return;
            }
 
            bool Subscribed;
 
            if (Item is null)
                Subscribed = false;
            else
                Subscribed = Item.State == SubscriptionState.To || Item.State == SubscriptionState.Both;
 
            if (Subscribed)
            {
                if (!await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.Question)],
                    ServiceRef.Localizer[nameof(AppResources.RemoveSubscriptionFrom), this.FriendlyName ?? string.Empty],
                    ServiceRef.Localizer[nameof(AppResources.Yes)], ServiceRef.Localizer[nameof(AppResources.Cancel)]))
                {
                    return;
                }
 
                ServiceRef.XmppService.RequestPresenceUnsubscription(this.BareJid);
 
                if (Item is not null && (Item.State == SubscriptionState.From || Item.State == SubscriptionState.Both))
                {
                    RemoveSubscriptionViewModel ViewModel = new(this.BareJid);
                    RemoveSubscriptionPopup Page = new(ViewModel);
 
                    await MopupService.Instance.PushAsync(Page);
                    bool? Remove = await ViewModel.Result;
 
                    if (Remove.HasValue && Remove.Value)
                    {
                        ServiceRef.XmppService.RequestRevokePresenceSubscription(this.BareJid);
 
                        if ((this.contact?.AllowSubscriptionFrom.HasValue ?? false) && this.contact.AllowSubscriptionFrom.Value)
                        {
                            this.contact.AllowSubscriptionFrom = null;
                            await Database.Update(this.contact);
                        }
                    }
                }
            }
            else
            {
                SubscribeToViewModel ViewModel = new(this.BareJid);
                SubscribeToPopup Page = new(ViewModel);
 
                await MopupService.Instance.PushAsync(Page);
                bool? SubscribeTo = await ViewModel.Result;
 
                if (SubscribeTo.HasValue && SubscribeTo.Value)
                {
                    string IdXml;
 
                    if (ServiceRef.TagProfile.LegalIdentity is null)
                        IdXml = string.Empty;
                    else
                    {
                        StringBuilder Xml = new();
                        ServiceRef.TagProfile.LegalIdentity.Serialize(Xml, true, true, true, true, true, true, true);
                        IdXml = Xml.ToString();
                    }
 
                    ServiceRef.XmppService.RequestPresenceSubscription(this.BareJid, IdXml);
                }
            }
        }
 
        public void PresenceUpdated()
        {
            this.OnPropertyChanged(nameof(this.ConnectionColor));
        }
 
        public void OnPropertyChanged(string PropertyName)
        {
            try
            {
                this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public event PropertyChangedEventHandler? PropertyChanged;
 
        public void NotificationsUpdated(NotificationEvent[] Events)
        {
            this.events = Events;
 
            this.OnPropertyChanged(nameof(this.Events));
            this.OnPropertyChanged(nameof(this.HasEvents));
            this.OnPropertyChanged(nameof(this.NrEvents));
        }
 
        public void AddEvent(NotificationEvent Event)
        {
            if (this.events is null)
                this.NotificationsUpdated([Event]);
            else
            {
                foreach (NotificationEvent Event2 in this.events)
                {
                    if (Event2.ObjectId == Event.ObjectId)
                        return;
                }
 
                int c = this.events.Length;
                NotificationEvent[] NewArray = new NotificationEvent[c + 1];
                Array.Copy(this.events, 0, NewArray, 0, c);
                NewArray[c] = Event;
 
                this.NotificationsUpdated(NewArray);
            }
        }
 
        public void RemoveEvent(NotificationEvent Event)
        {
            if (this.events is not null)
            {
                int i, c = this.events.Length;
 
                for (i = 0; i < c; i++)
                {
                    NotificationEvent Event2 = this.events[i];
 
                    if (Event2.ObjectId == Event.ObjectId)
                    {
                        NotificationEvent[] NewArray = new NotificationEvent[c - 1];
 
                        if (i > 0)
                            Array.Copy(this.events, 0, NewArray, 0, i);
 
                        if (i < c - 1)
                            Array.Copy(this.events, i + 1, NewArray, i, c - i - 1);
 
                        this.NotificationsUpdated(NewArray);
 
                        return;
                    }
                }
 
            }
        }
    }
}