ViewIdentityViewModel.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 System.ComponentModel;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
 
namespace NeuroAccessMaui.UI.Pages.Identity.ViewIdentity
{
    public partial class ViewIdentityViewModel : QrXmppViewModel
    {
        private readonly PhotosLoader photosLoader;
        private LegalIdentity? requestorIdentity;
        private string? requestorFullJid;
        private string? signatoryIdentityId;
        private string? petitionId;
        private byte[]? contentToSign;
 
        public ViewIdentityViewModel(ViewIdentityNavigationArgs? Args)
            : base()
        {
            this.photosLoader = new PhotosLoader(this.Photos);
 
            if (Args is not null)
            {
                this.LegalIdentity = Args.Identity ?? ServiceRef.TagProfile.LegalIdentity;
                this.requestorIdentity = Args.RequestorIdentity;
                this.requestorFullJid = Args.RequestorFullJid;
                this.signatoryIdentityId = Args.SignatoryIdentityId;
                this.petitionId = Args.PetitionId;
                this.Purpose = Args.Purpose;
                this.contentToSign = Args.ContentToSign;
            }
        }
 
        protected override async Task OnInitialize()
        {
            await base.OnInitialize();
 
            if (this.LegalIdentity is null)
            {
                this.LegalIdentity = ServiceRef.TagProfile.LegalIdentity;
                this.requestorIdentity = null;
                this.requestorFullJid = null;
                this.signatoryIdentityId = null;
                this.petitionId = null;
                this.Purpose = null;
                this.contentToSign = null;
                this.IsPersonal = true;
            }
            else
                this.IsPersonal = false;
 
            this.AssignProperties();
 
            if (this.ThirdParty)
            {
                ContactInfo? Info = this.BareJid is null ? null : await ContactInfo.FindByBareJid(this.BareJid);
 
                if ((Info is not null) &&
                    (Info.LegalIdentity is null ||
                    (Info.LegalId != this.LegalId &&
                    Info.LegalIdentity.Created < this.LegalIdentity!.Created &&
                    this.LegalIdentity.State == IdentityState.Approved)))
                {
                    Info.LegalId = this.LegalId;
                    Info.LegalIdentity = this.LegalIdentity;
                    Info.FriendlyName = ContactInfo.GetFriendlyName(this.LegalIdentity);
 
                    await Database.Update(Info);
                    await Database.Provider.Flush();
                }
                
                this.CanAddContact = Info is null;
                this.CanRemoveContact = Info is not null;
 
                this.NotifyCommandsCanExecuteChanged();
            }
 
            ServiceRef.TagProfile.Changed += this.TagProfile_Changed;
            ServiceRef.XmppService.LegalIdentityChanged += this.SmartContracts_LegalIdentityChanged;
        }
 
        protected override async Task OnDispose()
        {
            this.photosLoader.CancelLoadPhotos();
 
            ServiceRef.TagProfile.Changed -= this.TagProfile_Changed;
            ServiceRef.XmppService.LegalIdentityChanged -= this.SmartContracts_LegalIdentityChanged;
 
            this.LegalIdentity = null;
 
            await base.OnDispose();
        }
 
        private void AssignProperties()
        {
            this.Created = this.LegalIdentity?.Created ?? DateTime.MinValue;
            this.Updated = this.LegalIdentity?.Updated.GetDateOrNullIfMinValue();
            this.Expires = this.LegalIdentity?.To.GetDateOrNullIfMinValue();
            this.LegalId = this.LegalIdentity?.Id;
            this.NetworkId = this.LegalIdentity?.GetJid();
 
            if (this.requestorIdentity is not null)
                this.BareJid = this.requestorIdentity.GetJid(Constants.NotAvailableValue);
            else if (this.LegalIdentity is not null)
                this.BareJid = this.LegalIdentity.GetJid(Constants.NotAvailableValue);
            else
                this.BareJid = Constants.NotAvailableValue;
 
            if (this.LegalIdentity?.ClientPubKey is not null)
                this.PublicKey = Convert.ToBase64String(this.LegalIdentity.ClientPubKey);
            else
                this.PublicKey = string.Empty;
 
            this.State = this.LegalIdentity?.State ?? IdentityState.Rejected;
            this.From = this.LegalIdentity?.From.GetDateOrNullIfMinValue();
            this.To = this.LegalIdentity?.To.GetDateOrNullIfMinValue();
 
            if (this.LegalIdentity is not null)
            {
                this.FirstName = this.LegalIdentity[Constants.XmppProperties.FirstName];
                this.MiddleNames = this.LegalIdentity[Constants.XmppProperties.MiddleNames];
                this.LastNames = this.LegalIdentity[Constants.XmppProperties.LastNames];
                this.PersonalNumber = this.LegalIdentity[Constants.XmppProperties.PersonalNumber];
                this.Address = this.LegalIdentity[Constants.XmppProperties.Address];
                this.Address2 = this.LegalIdentity[Constants.XmppProperties.Address2];
                this.ZipCode = this.LegalIdentity[Constants.XmppProperties.ZipCode];
                this.Area = this.LegalIdentity[Constants.XmppProperties.Area];
                this.City = this.LegalIdentity[Constants.XmppProperties.City];
                this.Region = this.LegalIdentity[Constants.XmppProperties.Region];
                this.CountryCode = this.LegalIdentity[Constants.XmppProperties.Country];
                this.NationalityCode = this.LegalIdentity[Constants.XmppProperties.Nationality];
                this.Gender = this.LegalIdentity[Constants.XmppProperties.Gender];
 
                string BirthDayStr = this.LegalIdentity[Constants.XmppProperties.BirthDay];
                string BirthMonthStr = this.LegalIdentity[Constants.XmppProperties.BirthMonth];
                string BirthYearStr = this.LegalIdentity[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.LegalIdentity[Constants.XmppProperties.OrgName];
                this.OrgNumber = this.LegalIdentity[Constants.XmppProperties.OrgNumber];
                this.OrgDepartment = this.LegalIdentity[Constants.XmppProperties.OrgDepartment];
                this.OrgRole = this.LegalIdentity[Constants.XmppProperties.OrgRole];
                this.OrgAddress = this.LegalIdentity[Constants.XmppProperties.OrgAddress];
                this.OrgAddress2 = this.LegalIdentity[Constants.XmppProperties.OrgAddress2];
                this.OrgZipCode = this.LegalIdentity[Constants.XmppProperties.OrgZipCode];
                this.OrgArea = this.LegalIdentity[Constants.XmppProperties.OrgArea];
                this.OrgCity = this.LegalIdentity[Constants.XmppProperties.OrgCity];
                this.OrgRegion = this.LegalIdentity[Constants.XmppProperties.OrgRegion];
                this.OrgCountryCode = this.LegalIdentity[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.LegalIdentity[Constants.XmppProperties.Phone];
                this.EMail = this.LegalIdentity[Constants.XmppProperties.EMail];
                this.DeviceId = this.LegalIdentity[Constants.XmppProperties.DeviceId];
            }
            else
            {
                this.FirstName = string.Empty;
                this.MiddleNames = string.Empty;
                this.LastNames = string.Empty;
                this.PersonalNumber = string.Empty;
                this.Address = string.Empty;
                this.Address2 = string.Empty;
                this.ZipCode = string.Empty;
                this.Area = string.Empty;
                this.City = string.Empty;
                this.Region = string.Empty;
                this.CountryCode = string.Empty;
                this.NationalityCode = string.Empty;
                this.Gender = string.Empty;
                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 = string.Empty;
                this.EMail = string.Empty;
                this.DeviceId = string.Empty;
                this.NetworkId = Constants.NotAvailableValue;
            }
 
            this.IsApproved = this.LegalIdentity?.State == IdentityState.Approved;
            this.IsCreated = this.LegalIdentity?.State == IdentityState.Created;
 
            this.IsForReview = this.requestorIdentity is not null;
            this.ThirdParty = (this.LegalIdentity is not null) && !this.IsPersonal;
 
            this.IsForReviewFirstName = !string.IsNullOrWhiteSpace(this.FirstName) && this.IsForReview;
            this.IsForReviewMiddleNames = !string.IsNullOrWhiteSpace(this.MiddleNames) && this.IsForReview;
            this.IsForReviewLastNames = !string.IsNullOrWhiteSpace(this.LastNames) && this.IsForReview;
            this.IsForReviewPersonalNumber = !string.IsNullOrWhiteSpace(this.PersonalNumber) && this.IsForReview;
            this.IsForReviewAddress = !string.IsNullOrWhiteSpace(this.Address) && this.IsForReview;
            this.IsForReviewAddress2 = !string.IsNullOrWhiteSpace(this.Address2) && this.IsForReview;
            this.IsForReviewCity = !string.IsNullOrWhiteSpace(this.City) && this.IsForReview;
            this.IsForReviewZipCode = !string.IsNullOrWhiteSpace(this.ZipCode) && this.IsForReview;
            this.IsForReviewArea = !string.IsNullOrWhiteSpace(this.Area) && this.IsForReview;
            this.IsForReviewRegion = !string.IsNullOrWhiteSpace(this.Region) && this.IsForReview;
            this.IsForReviewCountry = !string.IsNullOrWhiteSpace(this.CountryCode) && this.IsForReview;
 
            this.IsForReviewOrgName = !string.IsNullOrWhiteSpace(this.OrgName) && this.IsForReview;
            this.IsForReviewOrgNumber = !string.IsNullOrWhiteSpace(this.OrgNumber) && this.IsForReview;
            this.IsForReviewOrgDepartment = !string.IsNullOrWhiteSpace(this.OrgDepartment) && this.IsForReview;
            this.IsForReviewOrgRole = !string.IsNullOrWhiteSpace(this.OrgRole) && this.IsForReview;
            this.IsForReviewOrgAddress = !string.IsNullOrWhiteSpace(this.OrgAddress) && this.IsForReview;
            this.IsForReviewOrgAddress2 = !string.IsNullOrWhiteSpace(this.OrgAddress2) && this.IsForReview;
            this.IsForReviewOrgCity = !string.IsNullOrWhiteSpace(this.OrgCity) && this.IsForReview;
            this.IsForReviewOrgZipCode = !string.IsNullOrWhiteSpace(this.OrgZipCode) && this.IsForReview;
            this.IsForReviewOrgArea = !string.IsNullOrWhiteSpace(this.OrgArea) && this.IsForReview;
            this.IsForReviewOrgRegion = !string.IsNullOrWhiteSpace(this.OrgRegion) && this.IsForReview;
            this.IsForReviewOrgCountry = !string.IsNullOrWhiteSpace(this.OrgCountryCode) && this.IsForReview;
 
            // QR
            if (this.LegalIdentity is null)
                this.RemoveQrCode();
            else
                this.GenerateQrCode(Constants.UriSchemes.CreateIdUri(this.LegalIdentity.Id));
 
            if (this.IsConnected)
                this.ReloadPhotos();
        }
 
        protected override Task XmppService_ConnectionStateChanged(object? Sender, XmppState NewState)
        {
            return MainThread.InvokeOnMainThreadAsync(async () =>
            {
                await base.XmppService_ConnectionStateChanged(Sender, NewState);
 
                this.NotifyCommandsCanExecuteChanged();
 
                if (this.IsConnected)
                {
                    await Task.Delay(Constants.Timeouts.XmppInit);
                    this.ReloadPhotos();
                }
            });
        }
 
        private async void ReloadPhotos()
        {
            try
            {
                this.photosLoader.CancelLoadPhotos();
 
                Attachment[]? Attachments;
 
                if (this.requestorIdentity?.Attachments is not null)
                    Attachments = this.requestorIdentity.Attachments;
                else
                    Attachments = this.LegalIdentity?.Attachments;
 
                if (Attachments is not null)
                {
                    Photo? First = await this.photosLoader.LoadPhotos(Attachments, SignWith.LatestApprovedIdOrCurrentKeys);
 
                    this.FirstPhotoSource = First?.Source;
                    this.FirstPhotoRotation = First?.Rotation ?? 0;
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        private void TagProfile_Changed(object? Sender, PropertyChangedEventArgs e)
        {
            MainThread.BeginInvokeOnMainThread(this.AssignProperties);
        }
 
        private Task SmartContracts_LegalIdentityChanged(object? Sender, LegalIdentityEventArgs e)
        {
            MainThread.BeginInvokeOnMainThread(() =>
            {
                if (this.LegalIdentity?.Id == e.Identity.Id)
                {
                    this.LegalIdentity = e.Identity;
                    this.AssignProperties();
                }
            });
 
            return Task.CompletedTask;
        }
 
        #region Properties
 
        public ObservableCollection<Photo> Photos { get; } = [];
 
        public LegalIdentity? LegalIdentity { get; private set; }
 
        [ObservableProperty]
        private string? purpose;
 
        [ObservableProperty]
        private DateTime created;
 
        [ObservableProperty]
        private DateTime? updated;
 
        [ObservableProperty]
        private DateTime? expires;
 
        [ObservableProperty]
        private string? legalId;
 
        [ObservableProperty]
        private string? networkId;
 
        [ObservableProperty]
        private string? bareJid;
 
        [ObservableProperty]
        private string? publicKey;
 
        [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 bool isCreated;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(IsNotForReview))]
        private bool isForReview;
 
        public bool IsNotForReview => !this.IsForReview;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(IsThirdPartyAndNotForReview))]
        private bool thirdParty;
 
        [ObservableProperty]
        private bool canAddContact = false;
 
        [ObservableProperty]
 
        private bool canRemoveContact = false;
 
        public bool IsThirdPartyAndNotForReview => this.ThirdParty && !this.IsForReview;
 
        [ObservableProperty]
        private bool isPersonal;
 
        [ObservableProperty]
        private bool firstNameIsChecked;
 
        [ObservableProperty]
        private bool middleNamesIsChecked;
 
        [ObservableProperty]
        private bool lastNamesIsChecked;
 
        [ObservableProperty]
        private bool personalNumberIsChecked;
 
        [ObservableProperty]
        private bool addressIsChecked;
 
        [ObservableProperty]
        private bool address2IsChecked;
 
        [ObservableProperty]
        private bool zipCodeIsChecked;
 
        [ObservableProperty]
        private bool areaIsChecked;
 
        [ObservableProperty]
        private bool cityIsChecked;
 
        [ObservableProperty]
        private bool regionIsChecked;
 
        [ObservableProperty]
        private bool countryCodeIsChecked;
 
        [ObservableProperty]
        private bool orgNameIsChecked;
 
        [ObservableProperty]
        private bool orgDepartmentIsChecked;
 
        [ObservableProperty]
        private bool orgRoleIsChecked;
 
        [ObservableProperty]
        private bool orgNumberIsChecked;
 
        [ObservableProperty]
        private bool orgAddressIsChecked;
 
        [ObservableProperty]
        private bool orgAddress2IsChecked;
 
        [ObservableProperty]
        private bool orgZipCodeIsChecked;
 
        [ObservableProperty]
        private bool orgAreaIsChecked;
 
        [ObservableProperty]
        private bool orgCityIsChecked;
 
        [ObservableProperty]
        private bool orgRegionIsChecked;
 
        [ObservableProperty]
        private bool orgCountryCodeIsChecked;
 
        [ObservableProperty]
        private bool carefulReviewIsChecked;
 
        [ObservableProperty]
        private bool approvePiiIsChecked;
 
        [ObservableProperty]
        private bool isForReviewFirstName;
 
        [ObservableProperty]
        private bool isForReviewMiddleNames;
 
        [ObservableProperty]
        private bool isForReviewLastNames;
 
        [ObservableProperty]
        private bool isForReviewPersonalNumber;
 
        [ObservableProperty]
        private bool isForReviewAddress;
 
        [ObservableProperty]
        private bool isForReviewAddress2;
 
        [ObservableProperty]
        private bool isForReviewCity;
 
        [ObservableProperty]
        private bool isForReviewZipCode;
 
        [ObservableProperty]
        private bool isForReviewArea;
 
        [ObservableProperty]
        private bool isForReviewRegion;
 
        [ObservableProperty]
        private bool isForReviewCountry;
 
        [ObservableProperty]
        private bool isForReviewOrgName;
 
        [ObservableProperty]
        private bool isForReviewOrgDepartment;
 
        [ObservableProperty]
        private bool isForReviewOrgRole;
 
        [ObservableProperty]
        private bool isForReviewOrgNumber;
 
        [ObservableProperty]
        private bool isForReviewOrgAddress;
 
        [ObservableProperty]
        private bool isForReviewOrgAddress2;
 
        [ObservableProperty]
        private bool isForReviewOrgCity;
 
        [ObservableProperty]
        private bool isForReviewOrgZipCode;
 
        [ObservableProperty]
        private bool isForReviewOrgArea;
 
        [ObservableProperty]
        private bool isForReviewOrgRegion;
 
        [ObservableProperty]
        private bool isForReviewOrgCountry;
 
        [ObservableProperty]
        private ImageSource? firstPhotoSource;
 
        [ObservableProperty]
        private int firstPhotoRotation;
 
        public bool CanExecuteCommands => !this.IsBusy && this.IsConnected;
 
        public string FullName => ContactInfo.GetFullName(this.FirstName, this.MiddleNames, this.LastNames);
 
        #endregion
 
        private void NotifyCommandsCanExecuteChanged()
        {
            this.AddContactCommand.NotifyCanExecuteChanged();
            this.RemoveContactCommand.NotifyCanExecuteChanged();
            this.ApproveCommand.NotifyCanExecuteChanged();
            this.RejectCommand.NotifyCanExecuteChanged();
        }
 
        public override void SetIsBusy(bool IsBusy)
        {
            base.SetIsBusy(IsBusy);
            this.NotifyCommandsCanExecuteChanged();
        }
 
        [RelayCommand]
        private async Task Copy(object Item)
        {
            try
            {
                this.SetIsBusy(true);
 
                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);
            }
            finally
            {
                this.SetIsBusy(false);
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanRemoveContact))]
        private async Task RemoveContact()
        {
            if (this.LegalIdentity is null)
                return;
            try
            {
                if (!await ServiceRef.UiService.DisplayAlert(ServiceRef.Localizer["Confirm"], ServiceRef.Localizer["AreYouSureYouWantToRemoveContact"], ServiceRef.Localizer["Yes"], ServiceRef.Localizer["Cancel"]))
                    return;
 
                string BareJid = this.LegalIdentity.GetJid();
 
                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.CanAddContact = true;
                this.CanRemoveContact = false;
                this.NotifyCommandsCanExecuteChanged();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanAddContact))]
        private async Task AddContact()
        {
            if (this.LegalIdentity is null)
                return;
 
 
            try
            {
                this.SetIsBusy(true);
 
                string FriendlyName = ContactInfo.GetFriendlyName(this.LegalIdentity);
                string BareJid = this.LegalIdentity.GetJid();
 
                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.LegalIdentity.Id,
                        LegalIdentity = this.LegalIdentity,
                        FriendlyName = FriendlyName,
                        IsThing = false
                    };
 
                    await Database.Insert(Info);
                }
                else
                {
                    Info.LegalId = this.LegalIdentity.Id;
                    Info.LegalIdentity = this.LegalIdentity;
                    Info.FriendlyName = FriendlyName;
 
                    await Database.Update(Info);
                }
                await ServiceRef.AttachmentCacheService.MakePermanent(this.LegalId!);
                await Database.Provider.Flush();
                this.CanAddContact = false;
                this.CanRemoveContact = true;
                this.NotifyCommandsCanExecuteChanged();
 
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
            finally
            {
                this.SetIsBusy(false);
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanExecuteCommands))]
        private async Task Approve()
        {
            if (this.requestorIdentity is null)
                return;
 
            try
            {
                if ((!string.IsNullOrEmpty(this.FirstName) && !this.FirstNameIsChecked) ||
                    (!string.IsNullOrEmpty(this.MiddleNames) && !this.MiddleNamesIsChecked) ||
                    (!string.IsNullOrEmpty(this.LastNames) && !this.LastNamesIsChecked) ||
                    (!string.IsNullOrEmpty(this.PersonalNumber) && !this.PersonalNumberIsChecked) ||
                    (!string.IsNullOrEmpty(this.Address) && !this.AddressIsChecked) ||
                    (!string.IsNullOrEmpty(this.Address2) && !this.Address2IsChecked) ||
                    (!string.IsNullOrEmpty(this.ZipCode) && !this.ZipCodeIsChecked) ||
                    (!string.IsNullOrEmpty(this.Area) && !this.AreaIsChecked) ||
                    (!string.IsNullOrEmpty(this.City) && !this.CityIsChecked) ||
                    (!string.IsNullOrEmpty(this.Region) && !this.RegionIsChecked) ||
                    (!string.IsNullOrEmpty(this.CountryCode) && !this.CountryCodeIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgName) && !this.OrgNameIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgDepartment) && !this.OrgDepartmentIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgRole) && !this.OrgRoleIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgNumber) && !this.OrgNumberIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgAddress) && !this.OrgAddressIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgAddress2) && !this.OrgAddress2IsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgZipCode) && !this.OrgZipCodeIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgArea) && !this.OrgAreaIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgCity) && !this.OrgCityIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgRegion) && !this.OrgRegionIsChecked) ||
                    (!string.IsNullOrEmpty(this.OrgCountryCode) && !this.OrgCountryCodeIsChecked))
                {
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.Incomplete)],
                        ServiceRef.Localizer[nameof(AppResources.PleaseReviewAndCheckAllCheckboxes)]);
                    return;
                }
 
                if (!this.CarefulReviewIsChecked)
                {
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.Incomplete)],
                        ServiceRef.Localizer[nameof(AppResources.YouNeedToCheckCarefullyReviewed)]);
                    return;
                }
 
                if (!this.ApprovePiiIsChecked)
                {
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.Incomplete)],
                        ServiceRef.Localizer[nameof(AppResources.YouNeedToApproveToAssociate)]);
                    return;
                }
 
                if (!await App.AuthenticateUser(AuthenticationPurpose.SignPetition, true))
                    return;
 
                (bool Succeeded1, byte[]? Signature) = await ServiceRef.NetworkService.TryRequest(
                    () => ServiceRef.XmppService.Sign(this.contentToSign!, SignWith.LatestApprovedId));
 
                if (!Succeeded1)
                    return;
 
                bool Succeeded2 = await ServiceRef.NetworkService.TryRequest(() =>
                {
                    return ServiceRef.XmppService.SendPetitionSignatureResponse(
                        this.signatoryIdentityId, this.contentToSign!, Signature!,
                        this.petitionId!, this.requestorFullJid!, true);
                });
 
                if (Succeeded2)
                    await this.GoBack();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanExecuteCommands))]
        private async Task Reject()
        {
            if (this.requestorIdentity is null)
                return;
 
            try
            {
                bool Succeeded = await ServiceRef.NetworkService.TryRequest(() =>
                {
                    return ServiceRef.XmppService.SendPetitionSignatureResponse(
                        this.signatoryIdentityId, this.contentToSign!, [],
                        this.petitionId!, this.requestorFullJid!, false);
                });
 
                if (Succeeded)
                    await this.GoBack();
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
                await ServiceRef.UiService.DisplayException(ex);
            }
        }
 
        #region ILinkableView
 
        public override Task<string> Title => Task.FromResult<string>(ContactInfo.GetFriendlyName(this.LegalIdentity!));
 
        #endregion
 
 
    }
}