PetitionPeerReviewViewModel.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.Data;
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.PetitionPeerReview
{
    public partial class PetitionPeerReviewViewModel : QrXmppViewModel
    {
        private readonly PhotosLoader photosLoader;
        private readonly string? requestorFullJid;
        private readonly string? requestedIdentityId;
        private readonly string? petitionId;
        private readonly string? bareJid;
 
        public PetitionPeerReviewViewModel(PetitionPeerReviewNavigationArgs? 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;
                this.ContentToSign = Args.ContentToSign;
 
                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;
            }
        }
 
        public void AddView(ReviewStep Step, BaseContentView View)
        {
            View.BindingContext = this;
            this.stepViews[Step] = View;
        }
 
        [ObservableProperty]
        private ReviewStep currentStep = ReviewStep.Photo;
 
        private readonly SortedDictionary<ReviewStep, BaseContentView> stepViews = [];
 
        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();
            this.NotifyCommandsCanExecuteChanged();
 
            this.ReloadPhotos();
        }
 
        private async void ReloadPhotos()
        {
            try
            {
                this.photosLoader.CancelLoadPhotos();
 
                Attachment[]? Attachments = this.RequestorIdentity?.Attachments;
                Photo? First;
 
                if (Attachments is not null)
                {
                    First = await this.photosLoader.LoadPhotos(Attachments, SignWith.LatestApprovedId);
 
                    this.FirstPhotoSource = First?.Source;
                    this.FirstPhotoRotation = First?.Rotation ?? 0;
                }
 
                Attachments = ServiceRef.TagProfile.LegalIdentity?.Attachments;
 
                if (Attachments is not null)
                {
                    First = await this.photosLoader.LoadPhotos(Attachments, SignWith.LatestApprovedId);
 
                    this.MyFirstPhotoSource = First?.Source;
                    this.MyFirstPhotoRotation = First?.Rotation ?? 0;
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
            }
        }
 
        protected override async Task OnDispose()
        {
            this.photosLoader.CancelLoadPhotos();
 
            await base.OnDispose();
        }
 
        public ObservableCollection<Photo> Photos { get; } = [];
 
        public LegalIdentity? RequestorIdentity { get; private set; }
 
        protected override Task XmppService_ConnectionStateChanged(object? Sender, XmppState NewState)
        {
            return MainThread.InvokeOnMainThreadAsync(async () =>
            {
                await base.XmppService_ConnectionStateChanged(Sender, NewState);
 
                this.NotifyCommandsCanExecuteChanged();
            });
        }
 
        public override void SetIsBusy(bool IsBusy)
        {
            base.SetIsBusy(IsBusy);
            this.NotifyCommandsCanExecuteChanged();
        }
 
        private void NotifyCommandsCanExecuteChanged()
        {
            this.AcceptCommand.NotifyCanExecuteChanged();
            this.DeclineCommand.NotifyCanExecuteChanged();
            this.AuthenticateReviewerCommand.NotifyCanExecuteChanged();
        }
 
        public bool CanAccept
        {
            get
            {
                if (!this.IsConnected || this.IsBusy || this.ContentToSign is null)
                    return false;
 
                if (this.HasPhoto && !this.IsPhotoOk)
                    return false;
 
                if (this.HasName && !this.IsNameOk)
                    return false;
 
                if (this.HasPersonalNumber && !this.IsPnrOk)
                    return false;
 
                if (this.HasNationality && !this.IsNationalityOk)
                    return false;
 
                if (this.HasBirthDate && !this.IsBirthDateOk)
                    return false;
 
                if (this.HasGender && !this.IsGenderOk)
                    return false;
 
                if (this.HasPersonalAddressInfo && !this.IsPersonalAddressInfoOk)
                    return false;
 
                if (this.HasOrganizationalInfo && !this.IsOrganizationalInfoOk)
                    return false;
 
                if (!this.AcknowledgeResponsibility || !this.ConsentProcessing || !this.ConfirmCorrect)
                    return false;
 
                return true;
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanAccept))]
        private Task Accept()
        {
            return this.Accept(true);
        }
 
        private async Task Accept(bool GoBackIfOk)
        {
            if (this.ContentToSign is null || !await App.AuthenticateUser(AuthenticationPurpose.AcceptPeerReview))
                return;
 
            bool Succeeded = await ServiceRef.NetworkService.TryRequest(async () =>
            {
                byte[] Signature = await ServiceRef.XmppService.Sign(this.ContentToSign!, SignWith.LatestApprovedId);
 
                await ServiceRef.XmppService.SendPetitionSignatureResponse(this.requestedIdentityId, this.ContentToSign, Signature,
                    this.petitionId!, this.requestorFullJid!, true);
            });
 
            if (Succeeded && GoBackIfOk)
                await base.GoBack();
        }
 
        public bool CanDecline => this.IsConnected && !this.IsBusy && this.ContentToSign is not null;
 
        [RelayCommand(CanExecute = nameof(CanDecline))]
        private Task Decline()
        {
            return this.Decline(true);
        }
 
        private async Task Decline(bool GoBackIfOk)
        {
            if (this.ContentToSign is null || !await App.AuthenticateUser(AuthenticationPurpose.DeclinePeerReview))
                return;
 
            bool Succeeded = await ServiceRef.NetworkService.TryRequest(async () =>
            {
                byte[] Signature = await ServiceRef.XmppService.Sign(this.ContentToSign!, SignWith.LatestApprovedId);
 
                await ServiceRef.XmppService.SendPetitionSignatureResponse(this.requestedIdentityId, this.ContentToSign, Signature,
                    this.petitionId!, this.requestorFullJid!, false);
            });
 
            if (Succeeded && GoBackIfOk)
                await base.GoBack();
        }
 
        [RelayCommand]
        private async Task Ignore()
        {
            await base.GoBack();
        }
 
        [RelayCommand(CanExecute = nameof(IsPhotoOk))]
        private void AcceptPhoto()
        {
            if (this.IsPhotoOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsNameOk))]
        private void AcceptName()
        {
            if (this.IsNameOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsPnrOk))]
        private void AcceptPnr()
        {
            if (this.IsPnrOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsNationalityOk))]
        private void AcceptNationality()
        {
            if (this.IsNationalityOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsBirthDateOk))]
        private void AcceptBirthDate()
        {
            if (this.IsBirthDateOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsGenderOk))]
        private void AcceptGender()
        {
            if (this.IsGenderOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsPersonalAddressInfoOk))]
        private void AcceptPersonalAddressInfo()
        {
            if (this.IsPersonalAddressInfoOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsOrganizationalInfoOk))]
        private void AcceptOrganizationalInfo()
        {
            if (this.IsOrganizationalInfoOk)
                this.NextPage();
        }
 
        [RelayCommand(CanExecute = nameof(IsConsentOk))]
        private void AcceptConsent()
        {
            if (this.IsConsentOk)
                this.NextPage();
        }
 
        private void NextPage()
        {
            ReviewStep Current = this.CurrentStep;
            bool IsVisible;
 
            do
            {
                Current++;
                IsVisible = Current switch
                {
                    ReviewStep.Photo => this.HasPhoto,
                    ReviewStep.Name => this.HasName,
                    ReviewStep.Pnr => this.HasPersonalNumber,
                    ReviewStep.Nationality => this.HasNationality,
                    ReviewStep.BirthDate => this.HasBirthDate,
                    ReviewStep.Gender => this.HasGender,
                    ReviewStep.PersonalAddressInfo => this.HasPersonalAddressInfo,
                    ReviewStep.OrganizationalInfo => this.HasOrganizationalInfo,
                    _ => true,
                };
            }
            while (!IsVisible);
 
            this.CurrentStep = Current;
        }
 
        private bool PrevPage()
        {
            ReviewStep Current = this.CurrentStep;
            bool IsVisible;
 
            do
            {
                if (Current == 0)
                    return false;
 
                Current--;
                IsVisible = Current switch
                {
                    ReviewStep.Photo => this.HasPhoto,
                    ReviewStep.Name => this.HasName,
                    ReviewStep.Pnr => this.HasPersonalNumber,
                    ReviewStep.Nationality => this.HasNationality,
                    ReviewStep.BirthDate => this.HasBirthDate,
                    ReviewStep.Gender => this.HasGender,
                    ReviewStep.PersonalAddressInfo => this.HasPersonalAddressInfo,
                    ReviewStep.OrganizationalInfo => this.HasOrganizationalInfo,
                    _ => true,
                };
            }
            while (!IsVisible);
 
            this.CurrentStep = Current;
 
            return true;
        }
 
        public bool HasPhoto => this.FirstPhotoSource is not null;
 
        public bool HasName => !string.IsNullOrEmpty(this.FullName);
 
        public bool HasPersonalNumber => !string.IsNullOrEmpty(this.PersonalNumber);
 
        public bool HasNationality => !string.IsNullOrEmpty(this.NationalityCode);
 
        public bool HasBirthDate => this.BirthDate is not null;
 
        public bool HasGender => !string.IsNullOrEmpty(this.Gender);
 
        public bool HasPersonalAddressInfo
        {
            get
            {
                return
                    !string.IsNullOrEmpty(this.Address) ||
                    !string.IsNullOrEmpty(this.Address2) ||
                    !string.IsNullOrEmpty(this.Area) ||
                    !string.IsNullOrEmpty(this.City) ||
                    !string.IsNullOrEmpty(this.Region) ||
                    !string.IsNullOrEmpty(this.CountryCode);
            }
        }
 
        public bool HasOrganizationalInfo
        {
            get
            {
                return
                    !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.OrgArea) ||
                    !string.IsNullOrEmpty(this.OrgCity) ||
                    !string.IsNullOrEmpty(this.OrgRegion) ||
                    !string.IsNullOrEmpty(this.OrgCountryCode);
            }
        }
 
        #region Properties
 
        [ObservableProperty]
        private DateTime created;
 
        [ObservableProperty]
        private DateTime? updated;
 
        [ObservableProperty]
        private string? legalId;
 
        [ObservableProperty]
        private IdentityState state;
 
        [ObservableProperty]
        private DateTime? from;
 
        [ObservableProperty]
        private DateTime? to;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        [NotifyPropertyChangedFor(nameof(PhotoReviewText))]
        [NotifyPropertyChangedFor(nameof(PeerReviewConfirmCorrectText))]
        [NotifyPropertyChangedFor(nameof(PeerReviewAuthenticationText))]
        [NotifyPropertyChangedFor(nameof(ReviewApproved))]
        private string? firstName;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        [NotifyPropertyChangedFor(nameof(PhotoReviewText))]
        [NotifyPropertyChangedFor(nameof(PeerReviewConfirmCorrectText))]
        [NotifyPropertyChangedFor(nameof(PeerReviewAuthenticationText))]
        [NotifyPropertyChangedFor(nameof(ReviewApproved))]
        private string? middleNames;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(FullName))]
        [NotifyPropertyChangedFor(nameof(PhotoReviewText))]
        [NotifyPropertyChangedFor(nameof(PeerReviewConfirmCorrectText))]
        [NotifyPropertyChangedFor(nameof(PeerReviewAuthenticationText))]
        [NotifyPropertyChangedFor(nameof(ReviewApproved))]
        private string? lastNames;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(PersonalNumberWithFlag))]
        private string? personalNumber;
 
        public string? PersonalNumberWithFlag
        {
            get
            {
                if (string.IsNullOrEmpty(this.CountryCode) ||
                    !ISO_3166_1.TryGetCountryByCode(this.CountryCode, out ISO_3166_Country? Country) ||
                    Country is null)
                {
                    return this.PersonalNumber;
                }
 
                return Country.EmojiInfo.Unicode + "\t" + this.PersonalNumber;
            }
        }
 
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static",
            Justification = "Must be instance property for view binding to work.")]
        public string? MyPersonalNumberWithFlag
        {
            get
            {
                if (ServiceRef.TagProfile.LegalIdentity is null)
                    return null;
 
                string? MyCountryCode = ServiceRef.TagProfile.LegalIdentity[Constants.XmppProperties.Country];
                string? MyPersonalNumber = ServiceRef.TagProfile.LegalIdentity[Constants.XmppProperties.PersonalNumber];
 
                if (string.IsNullOrEmpty(MyCountryCode) ||
                    !ISO_3166_1.TryGetCountryByCode(MyCountryCode, out ISO_3166_Country? MyCountry) ||
                    MyCountry is null)
                {
                    return MyPersonalNumber;
                }
 
                return MyCountry.EmojiInfo.Unicode + "\t" + MyPersonalNumber;
            }
        }
 
        [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]
        [NotifyPropertyChangedFor(nameof(PersonalNumberWithFlag))]
        private string? countryCode;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(NationalityWithFlag))]
        private string? nationalityCode;
 
        public string? NationalityWithFlag
        {
            get
            {
                if (string.IsNullOrEmpty(this.NationalityCode) ||
                    !ISO_3166_1.TryGetCountryByCode(this.NationalityCode, out ISO_3166_Country? Country) ||
                    Country is null)
                {
                    return this.NationalityCode;
                }
 
                return Country.EmojiInfo.Unicode + "\t" + Country.Name;
            }
        }
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(GenderWithSymbol))]
        private string? gender;
 
        public string? GenderWithSymbol
        {
            get
            {
                if (string.IsNullOrEmpty(this.Gender) ||
                    !ISO_5218.LetterToGender(this.Gender, out ISO_5218_Gender? Gender) ||
                    Gender is null)
                {
                    return this.Gender;
                }
 
                return Gender.Unicode + "\t" + ServiceRef.Localizer[Gender.LocalizedNameId];
            }
        }
 
        [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]
        [NotifyPropertyChangedFor(nameof(OrgRowHeight))]
        private bool hasOrg;
 
        public GridLength OrgRowHeight => this.HasOrg ? GridLength.Auto : new GridLength(0, GridUnitType.Absolute);
 
        [ObservableProperty]
        private string? phoneNr;
 
        [ObservableProperty]
        private string? eMail;
 
        [ObservableProperty]
        private string? deviceId;
 
        [ObservableProperty]
        private bool isApproved;
 
        [ObservableProperty]
        private string? purpose;
 
        [ObservableProperty]
        private byte[]? contentToSign;
 
        [ObservableProperty]
        private bool thirdPartyInContacts;
 
        [ObservableProperty]
        private ImageSource? firstPhotoSource;
 
        [ObservableProperty]
        private int firstPhotoRotation;
 
        [ObservableProperty]
        private ImageSource? myFirstPhotoSource;
 
        [ObservableProperty]
        private int myFirstPhotoRotation;
 
        // Full name of requesting entity.
        public string FullName => ContactInfo.GetFullName(this.FirstName, this.MiddleNames, this.LastNames);
 
        // Full name of reviewer.
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static",
            Justification = "Must be instance property for view binding to work.")]
        public string MyFullName => ContactInfo.GetFullName(ServiceRef.TagProfile.LegalIdentity);
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptPhotoCommand))]
        private bool isPhotoOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptNameCommand))]
        private bool isNameOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptPnrCommand))]
        private bool isPnrOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptNationalityCommand))]
        private bool isNationalityOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptBirthDateCommand))]
        private bool isBirthDateOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptGenderCommand))]
        private bool isGenderOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptPersonalAddressInfoCommand))]
        private bool isPersonalAddressInfoOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptOrganizationalInfoCommand))]
        private bool isOrganizationalInfoOk;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptConsentCommand))]
        [NotifyPropertyChangedFor(nameof(IsConsentOk))]
        private bool acknowledgeResponsibility;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptConsentCommand))]
        [NotifyPropertyChangedFor(nameof(IsConsentOk))]
        private bool consentProcessing;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(AcceptConsentCommand))]
        [NotifyPropertyChangedFor(nameof(IsConsentOk))]
        private bool confirmCorrect;
 
        [ObservableProperty]
        private bool showDetails;
 
        public bool IsConsentOk => this.AcknowledgeResponsibility && this.ConsentProcessing && this.ConfirmCorrect;
 
        public string PhotoReviewText => ServiceRef.Localizer[nameof(AppResources.PeerReviewPhotoText), this.FullName];
 
        public string PeerReviewConfirmCorrectText => ServiceRef.Localizer[nameof(AppResources.PeerReviewConfirmCorrectText), this.FullName];
 
        public string PeerReviewAuthenticationText => ServiceRef.Localizer[nameof(AppResources.PeerReviewAuthenticationText), this.FullName];
 
        public string ReviewApproved => ServiceRef.Localizer[nameof(AppResources.ReviewApproved), this.FullName];
 
        [RelayCommand]
        public void ToggleIsPhotoOk()
        {
            this.IsPhotoOk = !this.IsPhotoOk;
        }
 
        [RelayCommand]
        public void ToggleIsNameOk()
        {
            this.IsNameOk = !this.IsNameOk;
        }
 
        [RelayCommand]
        public void ToggleIsPnrOk()
        {
            this.IsPnrOk = !this.IsPnrOk;
        }
 
        [RelayCommand]
        public void ToggleIsNationalityOk()
        {
            this.IsNationalityOk = !this.IsNationalityOk;
        }
 
        [RelayCommand]
        public void ToggleIsBirthDateOk()
        {
            this.IsBirthDateOk = !this.IsBirthDateOk;
        }
 
        [RelayCommand]
        public void ToggleIsGenderOk()
        {
            this.IsGenderOk = !this.IsGenderOk;
        }
 
        [RelayCommand]
        public void ToggleIsPersonalAddressInfoOk()
        {
            this.IsPersonalAddressInfoOk = !this.IsPersonalAddressInfoOk;
        }
 
        [RelayCommand]
        public void ToggleIsOrganizationalInfoOk()
        {
            this.IsOrganizationalInfoOk = !this.IsOrganizationalInfoOk;
        }
 
        [RelayCommand]
        public void ToggleAcknowledgeResponsibility()
        {
            this.AcknowledgeResponsibility = !this.AcknowledgeResponsibility;
        }
 
        [RelayCommand]
        public void ToggleConsentProcessing()
        {
            this.ConsentProcessing = !this.ConsentProcessing;
        }
 
        [RelayCommand]
        public void ToggleConfirmCorrect()
        {
            this.ConfirmCorrect = !this.ConfirmCorrect;
        }
 
        [RelayCommand]
        public void ToggleShowDetails()
        {
            this.ShowDetails = !this.ShowDetails;
        }
 
        #endregion
 
        private void AssignProperties()
        {
            if (this.RequestorIdentity is not null)
            {
                this.Created = this.RequestorIdentity.Created;
                this.Updated = this.RequestorIdentity.Updated.GetDateOrNullIfMinValue();
                this.LegalId = this.RequestorIdentity.Id;
                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.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.PhoneNr = Constants.NotAvailableValue;
                this.EMail = Constants.NotAvailableValue;
                this.DeviceId = Constants.NotAvailableValue;
                this.IsApproved = false;
            }
        }
 
        [RelayCommand(CanExecute = nameof(CanAccept))]
        private async Task AuthenticateReviewer()
        {
            try
            {
                if (await App.AuthenticateUser(AuthenticationPurpose.AuthenticateReviewer, true))
                {
                    await this.Accept(false);
                    this.NextPage();
                }
            }
            catch (Exception ex)
            {
                ServiceRef.LogService.LogException(ex);
 
                await ServiceRef.UiService.DisplayAlert(
                    ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                    ServiceRef.Localizer[nameof(AppResources.UnableToSignReview)]);
            }
        }
 
        public override async Task GoBack()
        {
            if (!this.PrevPage())
                await base.GoBack();
        }
 
        [RelayCommand]
        public Task Close()
        {
            return base.GoBack();
        }
 
        #region ILinkableView
 
        public override Task<string> Title => Task.FromResult(ContactInfo.GetFriendlyName(this.RequestorIdentity!));
 
        #endregion
    }
}