PetitionSignatureViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Extensions;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Authentication;
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;
 
namespace NeuroAccessMaui.UI.Pages.Petitions.PetitionSignature
{
    public partial class PetitionSignatureViewModel : QrXmppViewModel
    {
        private readonly IAuthenticationService authenticationService = ServiceRef.Provider.GetRequiredService<IAuthenticationService>();
 
        private readonly PhotosLoader photosLoader;
        private readonly string? requestorFullJid;
        private readonly string? signatoryIdentityId;
        private readonly string? petitionId;
        private readonly byte[]? contentToSign;
 
        public PetitionSignatureViewModel(PetitionSignatureNavigationArgs? Args)
            : base()
        {
            this.photosLoader = new PhotosLoader(this.Photos);
 
            if (Args is null)
                return;
 
            this.RequestorIdentity = Args.RequestorIdentity;
            this.requestorFullJid = Args.RequestorFullJid;
            this.signatoryIdentityId = Args.SignatoryIdentityId;
            this.contentToSign = Args.ContentToSign;
            this.petitionId = Args.PetitionId;
            this.Purpose = Args.Purpose;
        }
 
        public override async Task OnInitializeAsync()
        {
            await base.OnInitializeAsync();
 
            this.AssignProperties();
 
            if (this.RequestorIdentity?.Attachments is not null)
                _ = this.photosLoader.LoadPhotos(this.RequestorIdentity.Attachments, SignWith.LatestApprovedId);
        }
 
        public override async Task OnDisposeAsync()
        {
            this.photosLoader.CancelLoadPhotos();
 
            await base.OnDisposeAsync();
        }
 
        public ObservableCollection<Photo> Photos { get; } = [];
 
        public LegalIdentity? RequestorIdentity { get; private set; }
 
        [RelayCommand]
        private async Task Accept()
        {
            if (!await this.authenticationService.AuthenticateUserAsync(AuthenticationPurpose.AcceptPetitionRequest, true))
                return;
 
            bool Succeeded = await ServiceRef.NetworkService.TryRequest(async () =>
            {
                byte[] Signature = await ServiceRef.XmppService.Sign(this.contentToSign!, SignWith.LatestApprovedId);
 
                await ServiceRef.XmppService.SendPetitionSignatureResponse(this.signatoryIdentityId, this.contentToSign!, Signature,
                    this.petitionId!, this.requestorFullJid!, true);
            });
 
            if (Succeeded)
                await this.GoBack();
        }
 
        [RelayCommand]
        private async Task Decline()
        {
            bool Succeeded = await ServiceRef.NetworkService.TryRequest(() =>
            {
                return ServiceRef.XmppService.SendPetitionSignatureResponse(this.signatoryIdentityId,
                    this.contentToSign!, [], this.petitionId!, this.requestorFullJid!, false);
            });
 
            if (Succeeded)
                await this.GoBack();
        }
 
        [RelayCommand]
        private async Task Ignore()
        {
            await this.GoBack();
        }
 
        public override Task<string> Title => Task.FromResult(this.FullName);
 
        // Full name of requesting entity.
        public string FullName => ContactInfo.GetFullName(this.FirstName, this.MiddleNames, this.LastNames);
 
        // The display name of the identity. If organization name is available, it is used, otherwise the full name.
        public string? DisplayName => string.IsNullOrEmpty(this.Domain) ? (this.HasOrg ? this.OrgName : this.FullName) : this.Domain;
 
 
        [ObservableProperty]
        [DefaultValue(false)]
        private bool hasDomain;
 
        #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))]
        [NotifyPropertyChangedFor(nameof(DisplayName))]
 
        private string? firstName;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        [NotifyPropertyChangedFor(nameof(DisplayName))]
 
        private string? middleNames;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        [NotifyPropertyChangedFor(nameof(DisplayName))]
        private string? lastNames;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(DisplayName))]
        private string? domain;
 
        [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]
        [NotifyPropertyChangedFor(nameof(DisplayName))]
        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]
        [NotifyPropertyChangedFor(nameof(DisplayName))]
        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]
        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];
                this.Domain = this.RequestorIdentity[Constants.XmppProperties.Domain];
                this.HasDomain = !string.IsNullOrEmpty(this.Domain);
 
                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.NetworkId = 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;
            }
 
            // QR
            if (this.RequestorIdentity is null)
                this.RemoveQrCode();
            else
                this.GenerateQrCode(Constants.UriSchemes.CreateIdUri(this.RequestorIdentity.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);
 
                if (this.IsConnected)
                {
                    await Task.Delay(Constants.Timeouts.XmppInit);
                    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.LatestApprovedIdOrCurrentKeys);
 
                    this.FirstPhotoSource = First?.Source;
                    this.FirstPhotoRotation = First?.Rotation ?? 0;
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        [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);
            }
        }
    }
}