PetitionContractViewModel.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 Waher.Networking.XMPP.Contracts;
 
namespace NeuroAccessMaui.UI.Pages.Petitions.PetitionContract
{
    public partial class PetitionContractViewModel : BaseViewModel
    {
        private readonly IAuthenticationService authenticationService = ServiceRef.Provider.GetRequiredService<IAuthenticationService>();
 
        private readonly string? requestorFullJid;
        private readonly string? petitionId;
        private readonly PhotosLoader photosLoader;
 
        public PetitionContractViewModel(PetitionContractNavigationArgs? Args)
        {
            this.Photos = [];
            this.photosLoader = new PhotosLoader(this.Photos);
 
            if (Args is not null)
            {
                this.RequestorIdentity = Args.RequestorIdentity;
                this.requestorFullJid = Args.RequestorFullJid;
                this.RequestedContract = Args.RequestedContract;
                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.LoadPhotos();
        }
 
        private async void LoadPhotos()
        {
            try
            {
                if (this.RequestorIdentity?.Attachments is not null)
                {
                    Photo? First = await this.photosLoader.LoadPhotos(this.RequestorIdentity.Attachments, SignWith.LatestApprovedId);
 
                    this.FirstPhotoSource = First?.Source;
                    this.FirstPhotoRotation = First?.Rotation ?? 0;
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        public override async Task OnDisposeAsync()
        {
            this.photosLoader.CancelLoadPhotos();
 
            await base.OnDisposeAsync();
        }
 
        public ObservableCollection<Photo> Photos { get; }
 
        public Contract? RequestedContract { get; private set; }
 
        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(() => ServiceRef.XmppService.SendPetitionContractResponse(
                this.RequestedContract!.ContractId, this.petitionId!, this.requestorFullJid!, true));
 
            if (Succeeded)
                await this.GoBack();
        }
 
        [RelayCommand]
        private async Task Decline()
        {
            bool succeeded = await ServiceRef.NetworkService.TryRequest(() => ServiceRef.XmppService.SendPetitionContractResponse(
                this.RequestedContract!.ContractId, 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]
        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 = DateTime.MinValue;
                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 = 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 = 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);
            }
        }
    }
}