PetitionIdentityViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Extensions;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Contacts;
using NeuroAccessMaui.Services.UI.Photos;
using System.Collections.ObjectModel;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
 
namespace NeuroAccessMaui.UI.Pages.Petitions.PetitionIdentity
{
    public partial class PetitionIdentityViewModel : BaseViewModel
    {
        private readonly PhotosLoader photosLoader;
        private readonly string? requestorFullJid;
        private readonly string? requestedIdentityId;
        private readonly string? petitionId;
        private readonly string? bareJid;
 
        public PetitionIdentityViewModel(PetitionIdentityNavigationArgs? Args)
        {
            this.photosLoader = new PhotosLoader(this.Photos);
 
            if (Args is not null)
            {
                this.RequestorIdentity = Args.RequestorIdentity;
                this.requestorFullJid = Args.RequestorFullJid;
                this.requestedIdentityId = Args.RequestedIdentityId;
                this.petitionId = Args.PetitionId;
                this.Purpose = Args.Purpose;
 
                if (!string.IsNullOrEmpty(this.requestorFullJid))
                    this.bareJid = XmppClient.GetBareJID(this.requestorFullJid);
                else if (Args.RequestorIdentity is not null)
                    this.bareJid = Args.RequestorIdentity.GetJid();
                else
                    this.bareJid = string.Empty;
            }
        }
 
        protected override async Task OnInitialize()
        {
            await base.OnInitialize();
 
            if (!string.IsNullOrEmpty(this.bareJid))
            {
                ContactInfo Info = await ContactInfo.FindByBareJid(this.bareJid);
 
                if (this.RequestorIdentity is not null &&
                    Info is not null &&
                    (Info.LegalIdentity is null || (
                    Info.LegalId != this.RequestorIdentity?.Id &&
                    Info.LegalIdentity is not null &&
                    Info.LegalIdentity.Created < this.RequestorIdentity!.Created &&
                    this.RequestorIdentity.State == IdentityState.Approved)))
                {
                    Info.LegalId = this.LegalId;
                    Info.LegalIdentity = this.RequestorIdentity;
                    Info.FriendlyName = ContactInfo.GetFriendlyName(this.RequestorIdentity);
 
                    await Database.Update(Info);
                    await Database.Provider.Flush();
                }
 
                this.ThirdPartyInContacts = Info is not null;
            }
 
            this.AssignProperties();
            EvaluateAllCommands();
 
            this.ReloadPhotos();
        }
 
        private async void ReloadPhotos()
        {
            try
            {
                this.photosLoader.CancelLoadPhotos();
 
                Attachment[]? Attachments = this.RequestorIdentity?.Attachments;
 
                if (Attachments is not null)
                {
                    Photo? First = await this.photosLoader.LoadPhotos(Attachments, SignWith.LatestApprovedId);
 
                    this.FirstPhotoSource = First?.Source;
                    this.FirstPhotoRotation = First?.Rotation ?? 0;
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        protected override async Task OnDispose()
        {
            this.photosLoader.CancelLoadPhotos();
 
            await base.OnDispose();
        }
 
        private static void EvaluateAllCommands()
        {
        }
 
        public ObservableCollection<Photo> Photos { get; } = [];
 
        public LegalIdentity? RequestorIdentity { get; private set; }
 
        [RelayCommand]
        private async Task Accept()
        {
            if (!await App.AuthenticateUser(AuthenticationPurpose.PetitionIdentity))
                return;
 
            bool Succeeded = await ServiceRef.NetworkService.TryRequest(() =>
            {
                return ServiceRef.XmppService.SendPetitionIdentityResponse(this.requestedIdentityId, this.petitionId!,
                    this.requestorFullJid!, true);
            });
 
            if (Succeeded)
                await ServiceRef.UiService.GoBackAsync();
        }
 
        [RelayCommand]
        private async Task Decline()
        {
            bool Succeeded = await ServiceRef.NetworkService.TryRequest(() =>
            {
                return ServiceRef.XmppService.SendPetitionIdentityResponse(this.requestedIdentityId, this.petitionId!,
                    this.requestorFullJid!, false);
            });
 
            if (Succeeded)
                await this.GoBack();
        }
 
        [RelayCommand]
        private async Task Ignore()
        {
            await this.GoBack();
        }
 
        // Full name of requesting entity.
        public string FullName => ContactInfo.GetFullName(this.FirstName, this.MiddleNames, this.LastNames);
 
        #region Properties
 
        [ObservableProperty]
        private DateTime created;
 
        [ObservableProperty]
        private DateTime? updated;
 
        [ObservableProperty]
        private DateTime? expires;
 
        [ObservableProperty]
        private string? legalId;
 
        [ObservableProperty]
        private string? networkId;
 
        [ObservableProperty]
        private IdentityState state;
 
        [ObservableProperty]
        private DateTime? from;
 
        [ObservableProperty]
        private DateTime? to;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        private string? firstName;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        private string? middleNames;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        private string? lastNames;
 
        [ObservableProperty]
        private string? personalNumber;
 
        [ObservableProperty]
        private string? address;
 
        [ObservableProperty]
        private string? address2;
 
        [ObservableProperty]
        private string? zipCode;
 
        [ObservableProperty]
        private string? area;
 
        [ObservableProperty]
        private string? city;
 
        [ObservableProperty]
        private string? region;
 
        [ObservableProperty]
        private string? countryCode;
 
        [ObservableProperty]
        private string? nationalityCode;
 
        [ObservableProperty]
        private string? gender;
 
        [ObservableProperty]
        private DateTime? birthDate;
 
        [ObservableProperty]
        private string? orgName;
 
        [ObservableProperty]
        private string? orgNumber;
 
        [ObservableProperty]
        private string? orgDepartment;
 
        [ObservableProperty]
        private string? orgRole;
 
        [ObservableProperty]
        private string? orgAddress;
 
        [ObservableProperty]
        private string? orgAddress2;
 
        [ObservableProperty]
        private string? orgZipCode;
 
        [ObservableProperty]
        private string? orgArea;
 
        [ObservableProperty]
        private string? orgCity;
 
        [ObservableProperty]
        private string? orgRegion;
 
        [ObservableProperty]
        private string? orgCountryCode;
 
        [ObservableProperty]
        private bool hasOrg;
 
        [ObservableProperty]
        private bool hasPhotos;
 
        [ObservableProperty]
        private string? phoneNr;
 
        [ObservableProperty]
        private string? eMail;
 
        [ObservableProperty]
        private string? deviceId;
 
        [ObservableProperty]
        private bool isApproved;
 
        [ObservableProperty]
        private string? purpose;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AddContactCommand))]
        [NotifyCanExecuteChangedFor(nameof(RemoveContactCommand))]
        private bool thirdPartyInContacts;
 
        [ObservableProperty]
        private ImageSource? firstPhotoSource;
 
        [ObservableProperty]
        private int firstPhotoRotation;
 
        #endregion
 
        private void AssignProperties()
        {
            if (this.RequestorIdentity is not null)
            {
                this.Created = this.RequestorIdentity.Created;
                this.Updated = this.RequestorIdentity.Updated.GetDateOrNullIfMinValue();
                this.Expires = this.RequestorIdentity.To.GetDateOrNullIfMinValue();
                this.LegalId = this.RequestorIdentity.Id;
                this.NetworkId = this.RequestorIdentity.GetJid();
                this.State = this.RequestorIdentity.State;
                this.From = this.RequestorIdentity.From.GetDateOrNullIfMinValue();
                this.To = this.RequestorIdentity.To.GetDateOrNullIfMinValue();
                this.FirstName = this.RequestorIdentity[Constants.XmppProperties.FirstName];
                this.MiddleNames = this.RequestorIdentity[Constants.XmppProperties.MiddleNames];
                this.LastNames = this.RequestorIdentity[Constants.XmppProperties.LastNames];
                this.PersonalNumber = this.RequestorIdentity[Constants.XmppProperties.PersonalNumber];
                this.Address = this.RequestorIdentity[Constants.XmppProperties.Address];
                this.Address2 = this.RequestorIdentity[Constants.XmppProperties.Address2];
                this.ZipCode = this.RequestorIdentity[Constants.XmppProperties.ZipCode];
                this.Area = this.RequestorIdentity[Constants.XmppProperties.Area];
                this.City = this.RequestorIdentity[Constants.XmppProperties.City];
                this.Region = this.RequestorIdentity[Constants.XmppProperties.Region];
                this.CountryCode = this.RequestorIdentity[Constants.XmppProperties.Country];
                this.NationalityCode = this.RequestorIdentity[Constants.XmppProperties.Nationality];
                this.Gender = this.RequestorIdentity[Constants.XmppProperties.Gender];
 
                string BirthDayStr = this.RequestorIdentity[Constants.XmppProperties.BirthDay];
                string BirthMonthStr = this.RequestorIdentity[Constants.XmppProperties.BirthMonth];
                string BirthYearStr = this.RequestorIdentity[Constants.XmppProperties.BirthYear];
 
                if (!string.IsNullOrEmpty(BirthDayStr) && int.TryParse(BirthDayStr, out int BirthDay) &&
                    !string.IsNullOrEmpty(BirthMonthStr) && int.TryParse(BirthMonthStr, out int BirthMonth) &&
                    !string.IsNullOrEmpty(BirthYearStr) && int.TryParse(BirthYearStr, out int BirthYear))
                {
                    try
                    {
                        this.BirthDate = new DateTime(BirthYear, BirthMonth, BirthDay);
                    }
                    catch (Exception ex)
                    {
                        ServiceRef.LogService.LogException(ex);
                        this.BirthDate = null;
                    }
                }
 
                this.OrgName = this.RequestorIdentity[Constants.XmppProperties.OrgName];
                this.OrgNumber = this.RequestorIdentity[Constants.XmppProperties.OrgNumber];
                this.OrgDepartment = this.RequestorIdentity[Constants.XmppProperties.OrgDepartment];
                this.OrgRole = this.RequestorIdentity[Constants.XmppProperties.OrgRole];
                this.OrgAddress = this.RequestorIdentity[Constants.XmppProperties.OrgAddress];
                this.OrgAddress2 = this.RequestorIdentity[Constants.XmppProperties.OrgAddress2];
                this.OrgZipCode = this.RequestorIdentity[Constants.XmppProperties.OrgZipCode];
                this.OrgArea = this.RequestorIdentity[Constants.XmppProperties.OrgArea];
                this.OrgCity = this.RequestorIdentity[Constants.XmppProperties.OrgCity];
                this.OrgRegion = this.RequestorIdentity[Constants.XmppProperties.OrgRegion];
                this.OrgCountryCode = this.RequestorIdentity[Constants.XmppProperties.OrgCountry];
                this.HasOrg =
                    !string.IsNullOrEmpty(this.OrgName) ||
                    !string.IsNullOrEmpty(this.OrgNumber) ||
                    !string.IsNullOrEmpty(this.OrgDepartment) ||
                    !string.IsNullOrEmpty(this.OrgRole) ||
                    !string.IsNullOrEmpty(this.OrgAddress) ||
                    !string.IsNullOrEmpty(this.OrgAddress2) ||
                    !string.IsNullOrEmpty(this.OrgZipCode) ||
                    !string.IsNullOrEmpty(this.OrgArea) ||
                    !string.IsNullOrEmpty(this.OrgCity) ||
                    !string.IsNullOrEmpty(this.OrgRegion) ||
                    !string.IsNullOrEmpty(this.OrgCountryCode);
                this.HasPhotos = this.Photos.Count > 0;
                this.PhoneNr = this.RequestorIdentity[Constants.XmppProperties.Phone];
                this.EMail = this.RequestorIdentity[Constants.XmppProperties.EMail];
                this.DeviceId = this.RequestorIdentity[Constants.XmppProperties.DeviceId];
                this.IsApproved = this.RequestorIdentity.State == IdentityState.Approved;
            }
            else
            {
                this.Created = DateTime.MinValue;
                this.Updated = null;
                this.LegalId = Constants.NotAvailableValue;
                this.State = IdentityState.Compromised;
                this.From = null;
                this.To = null;
                this.FirstName = Constants.NotAvailableValue;
                this.MiddleNames = Constants.NotAvailableValue;
                this.LastNames = Constants.NotAvailableValue;
                this.PersonalNumber = Constants.NotAvailableValue;
                this.Address = Constants.NotAvailableValue;
                this.Address2 = Constants.NotAvailableValue;
                this.ZipCode = Constants.NotAvailableValue;
                this.Area = Constants.NotAvailableValue;
                this.City = Constants.NotAvailableValue;
                this.Region = Constants.NotAvailableValue;
                this.CountryCode = Constants.NotAvailableValue;
                this.NationalityCode = Constants.NotAvailableValue;
                this.Gender = Constants.NotAvailableValue;
                this.BirthDate = null;
                this.OrgName = Constants.NotAvailableValue;
                this.OrgNumber = Constants.NotAvailableValue;
                this.OrgDepartment = Constants.NotAvailableValue;
                this.OrgRole = Constants.NotAvailableValue;
                this.OrgAddress = Constants.NotAvailableValue;
                this.OrgAddress2 = Constants.NotAvailableValue;
                this.OrgZipCode = Constants.NotAvailableValue;
                this.OrgArea = Constants.NotAvailableValue;
                this.OrgCity = Constants.NotAvailableValue;
                this.OrgRegion = Constants.NotAvailableValue;
                this.OrgCountryCode = Constants.NotAvailableValue;
                this.HasOrg = false;
                this.HasPhotos = false;
                this.PhoneNr = Constants.NotAvailableValue;
                this.EMail = Constants.NotAvailableValue;
                this.DeviceId = Constants.NotAvailableValue;
                this.IsApproved = false;
            }
        }
 
        [RelayCommand]
        private async Task Copy(object Item)
        {
            try
            {
                if (Item is string Label)
                {
                    if (Label == this.LegalId)
                    {
                        await Clipboard.SetTextAsync(Constants.UriSchemes.IotId + ":" + this.LegalId);
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                            ServiceRef.Localizer[nameof(AppResources.IdCopiedSuccessfully)]);
                    }
                    else
                    {
                        await Clipboard.SetTextAsync(Label);
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                            ServiceRef.Localizer[nameof(AppResources.TagValueCopiedToClipboard)]);
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public bool CanAddContact => !this.ThirdPartyInContacts;
 
        [RelayCommand(CanExecute = nameof(CanAddContact))]
        private async Task AddContact()
        {
            if (this.RequestorIdentity is null)
                return;
 
            try
            {
                string FriendlyName = ContactInfo.GetFriendlyName(this.RequestorIdentity);
                string BareJid = XmppClient.GetBareJID(this.requestorFullJid);
 
                RosterItem? Item = ServiceRef.XmppService.GetRosterItem(BareJid);
                if (Item is null)
                    ServiceRef.XmppService.AddRosterItem(new RosterItem(BareJid, FriendlyName));
 
                ContactInfo Info = await ContactInfo.FindByBareJid(BareJid);
                if (Info is null)
                {
                    Info = new ContactInfo()
                    {
                        BareJid = BareJid,
                        LegalId = this.RequestorIdentity.Id,
                        LegalIdentity = this.RequestorIdentity,
                        FriendlyName = FriendlyName,
                        IsThing = false
                    };
 
                    await Database.Insert(Info);
                }
                else
                {
                    Info.LegalId = this.requestedIdentityId;
                    Info.LegalIdentity = this.RequestorIdentity;
                    Info.FriendlyName = FriendlyName;
 
                    await Database.Update(Info);
                }
 
                await ServiceRef.AttachmentCacheService.MakePermanent(this.LegalId!);
                await Database.Provider.Flush();
 
                this.ThirdPartyInContacts = true;
            }
            catch (Exception ex)
            {
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        public bool CanRemoveContact => this.ThirdPartyInContacts;
 
        [RelayCommand(CanExecute = nameof(CanRemoveContact))]
        private async Task RemoveContact()
        {
            try
            {
                if (!await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer[nameof(AppResources.Confirm)],
                    ServiceRef.Localizer[nameof(AppResources.AreYouSureYouWantToRemoveContact)],
                    ServiceRef.Localizer[nameof(AppResources.Yes)], ServiceRef.Localizer[nameof(AppResources.Cancel)]))
                {
                    return;
                }
 
                string BareJid = XmppClient.GetBareJID(this.requestorFullJid);
 
                ContactInfo Info = await ContactInfo.FindByBareJid(BareJid);
                if (Info is not null)
                {
                    await Database.Delete(Info);
                    await ServiceRef.AttachmentCacheService.MakeTemporary(Info.LegalId);
                    await Database.Provider.Flush();
                }
 
                RosterItem? Item = ServiceRef.XmppService.GetRosterItem(BareJid);
                if (Item is not null)
                    ServiceRef.XmppService.RemoveRosterItem(BareJid);
 
                this.ThirdPartyInContacts = false;
            }
            catch (Exception ex)
            {
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
    }
}