RegisterIdentityModel.cs

using System.Collections.ObjectModel;
using System.Globalization;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Data;
using NeuroAccessMaui.Services.Data.PersonalNumbers;
using NeuroAccessMaui.Services.Xmpp;
using NeuroAccessMaui.UI.Pages.Applications.ApplyId;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
 
namespace NeuroAccessMaui.UI.Pages.Onboarding
{
    public partial class RegisterIdentityModel : XmppViewModel
    {
        public RegisterIdentityModel()
            : base()
        {
        }
 
        public override async Task OnInitializeAsync()
        {
            await base.OnInitializeAsync();
 
            this.NotifyCommandsCanExecuteChanged();
        }
 
        protected override Task XmppService_ConnectionStateChanged(object? Sender, XmppState NewState)
        {
            return MainThread.InvokeOnMainThreadAsync(async () =>
            {
                await base.XmppService_ConnectionStateChanged(Sender, NewState);
                await this.OnConnected();
            });
        }
 
        protected virtual Task OnConnected()
        {
            this.NotifyCommandsCanExecuteChanged();
            return Task.CompletedTask;
        }
 
        public override void SetIsBusy(bool IsBusy)
        {
            base.SetIsBusy(IsBusy);
            this.NotifyCommandsCanExecuteChanged();
        }
 
        protected virtual void NotifyCommandsCanExecuteChanged()
        {
            this.ApplyCommand.NotifyCanExecuteChanged();
        }
 
        public ObservableCollection<ObservableAttachmentCard> AdditionalPhotos { get; } = [];
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(FirstNameOk))]
        private string? firstName = "";
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(MiddleNamesOk))]
        private string? middleNames;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(LastNamesOk))]
        private string? lastNames;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(PersonalNumberOk))]
        private string? personalNumber;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(AddressOk))]
        private string? address;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(Address2Ok))]
        private string? address2;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(ZipCodeOk))]
        private string? zipCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(AreaOk))]
        private string? area;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(CityOk))]
        private string? city;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(RegionOk))]
        private string? region;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(CountryOk))]
        [NotifyPropertyChangedFor(nameof(PersonalNumberPlaceholder))]
        private string? countryCode;
 
        public string? PersonalNumberPlaceholder => string.IsNullOrEmpty(this.CountryCode) ? string.Empty: PersonalNumberSchemes.DisplayStringForCountry(this.CountryCode);
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(NationalityOk))]
        private string? nationalityCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(GenderOk))]
        private string? genderCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(BirthDateOk))]
        [NotifyPropertyChangedFor(nameof(NullIfInvalidBirthDate))]
        private DateTime birthDate = DateTime.Today;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgNameOk))]
        private string? orgName;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgNumberOk))]
        private string? orgNumber;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgAddressOk))]
        private string? orgAddress;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgAddress2Ok))]
        private string? orgAddress2;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgZipCodeOk))]
        private string? orgZipCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgAreaOk))]
        private string? orgArea;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgCityOk))]
        private string? orgCity;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgRegionOk))]
        private string? orgRegion;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        private string? orgCountryCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgDepartmentOk))]
        private string? orgDepartment;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgRoleOk))]
        private string? orgRole;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        private string? phoneNr;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        private string? eMail;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        private string? deviceId;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        private string? jid;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(FirstNameOk))]
        private bool requiresFirstName;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(MiddleNamesOk))]
        private bool requiresMiddleNames;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(LastNamesOk))]
        private bool requiresLastNames;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(PersonalNumberOk))]
        private bool requiresPersonalNumber;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(AddressOk))]
        private bool requiresAddress;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(Address2Ok))]
        private bool requiresAddress2;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(ZipCodeOk))]
        private bool requiresZipCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(AreaOk))]
        private bool requiresArea;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(CityOk))]
        private bool requiresCity;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(RegionOk))]
        private bool requiresRegion;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(CountryOk))]
        private bool requiresCountry;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(CountryOk))]
        private bool requiresCountryIso3166;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(NationalityOk))]
        private bool requiresNationality;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(GenderOk))]
        private bool requiresGender;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(BirthDateOk))]
        private bool requiresBirthDate;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgNameOk))]
        private bool requiresOrgName;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgDepartmentOk))]
        private bool requiresOrgDepartment;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgRoleOk))]
        private bool requiresOrgRole;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgNumberOk))]
        private bool requiresOrgNumber;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgAddressOk))]
        private bool requiresOrgAddress;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgAddress2Ok))]
        private bool requiresOrgAddress2;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgZipCodeOk))]
        private bool requiresOrgZipCode;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgAreaOk))]
        private bool requiresOrgArea;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgCityOk))]
        private bool requiresOrgCity;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgRegionOk))]
        private bool requiresOrgRegion;
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ApplyCommand))]
        [NotifyPropertyChangedFor(nameof(OrgCountryOk))]
        private bool requiresOrgCountry;
 
        public bool FirstNameOk => !this.RequiresFirstName || !string.IsNullOrWhiteSpace(this.FirstName);
 
        public bool MiddleNamesOk => !this.RequiresMiddleNames || !string.IsNullOrWhiteSpace(this.MiddleNames);
 
        public bool LastNamesOk => !this.RequiresLastNames || !string.IsNullOrWhiteSpace(this.LastNames);
 
        public bool PersonalNumberOk
        {
            get
            {
                if (string.IsNullOrWhiteSpace(this.PersonalNumber))
                    return !this.RequiresPersonalNumber;
 
                if (string.IsNullOrWhiteSpace(this.CountryCode))
                    return false;
 
                NumberInformation Info = PersonalNumberSchemes.Validate(this.CountryCode, this.PersonalNumber).Result;
 
                return !Info.IsValid.HasValue || Info.IsValid.Value;
            }
        }
 
        public bool AddressOk => !this.RequiresAddress || !string.IsNullOrWhiteSpace(this.Address);
 
        public bool Address2Ok => !this.RequiresAddress2 || !string.IsNullOrWhiteSpace(this.Address2);
 
        public bool ZipCodeOk => !this.RequiresZipCode || !string.IsNullOrWhiteSpace(this.ZipCode);
 
        public bool AreaOk => !this.RequiresArea || !string.IsNullOrWhiteSpace(this.Area);
 
        public bool CityOk => !this.RequiresCity || !string.IsNullOrWhiteSpace(this.City);
 
        public bool RegionOk => !this.RequiresRegion || !string.IsNullOrWhiteSpace(this.Region);
 
        public bool CountryOk
        {
            get
            {
                if (string.IsNullOrWhiteSpace(this.CountryCode))
                    return !this.RequiresCountry;
 
                if (this.RequiresCountryIso3166 && !ISO_3166_1.TryGetCountryByCode(this.CountryCode, out _))
                    return false;
 
                return true;
            }
        }
 
        public bool NationalityOk
        {
            get
            {
                if (string.IsNullOrWhiteSpace(this.NationalityCode))
                    return !this.RequiresNationality;
 
                if (this.RequiresCountryIso3166 && !ISO_3166_1.TryGetCountryByCode(this.NationalityCode, out _))
                    return false;
 
                return true;
            }
        }
 
        public bool GenderOk
        {
            get
            {
                if (string.IsNullOrEmpty(this.GenderCode))
                    return !this.RequiresGender;
 
                return ISO_5218.LetterToGender(this.GenderCode, out _);
            }
        }
 
        public DateTime MaxBirthDate => DateTime.Today.AddYears(-Constants.Age.MinAge);
 
        public DateTime MinBirthDate => DateTime.Today.AddYears(-Constants.Age.MaxAge);
 
        public DateTime? NullIfInvalidBirthDate
        {
            get => (this.BirthDate == DateTime.Today) ? null : this.BirthDate;
            set => this.BirthDate = value ?? DateTime.Today;
        }
        public bool BirthDateOk
        {
            get
            {
                if (this.NullIfInvalidBirthDate.HasValue && (this.BirthDate > this.MaxBirthDate || this.BirthDate < this.MinBirthDate))
                    return false;
 
                return !this.RequiresBirthDate;
            }
        }
 
        public bool OrgNameOk => !this.RequiresOrgName || !string.IsNullOrWhiteSpace(this.OrgName);
 
        public bool OrgDepartmentOk => !this.RequiresOrgDepartment || !string.IsNullOrWhiteSpace(this.OrgDepartment);
 
        public bool OrgRoleOk => !this.RequiresOrgRole || !string.IsNullOrWhiteSpace(this.OrgRole);
 
        public bool OrgNumberOk => !this.RequiresOrgNumber || !string.IsNullOrEmpty(this.OrgNumber);
 
        public bool OrgAddressOk => !this.RequiresOrgAddress || !string.IsNullOrWhiteSpace(this.OrgAddress);
 
        public bool OrgAddress2Ok => !this.RequiresOrgAddress2 || !string.IsNullOrWhiteSpace(this.OrgAddress2);
 
        public bool OrgZipCodeOk => !this.RequiresOrgZipCode || !string.IsNullOrWhiteSpace(this.OrgZipCode);
 
        public bool OrgAreaOk => !this.RequiresOrgArea || !string.IsNullOrWhiteSpace(this.OrgArea);
 
        public bool OrgCityOk => !this.RequiresOrgCity || !string.IsNullOrWhiteSpace(this.OrgCity);
 
        public bool OrgRegionOk => !this.RequiresOrgRegion || !string.IsNullOrWhiteSpace(this.OrgRegion);
 
        public bool OrgCountryOk
        {
            get
            {
                if (string.IsNullOrWhiteSpace(this.OrgCountryCode))
                    return !this.RequiresOrgCountry;
 
                if (this.RequiresCountryIso3166 && !ISO_3166_1.TryGetCountryByCode(this.OrgCountryCode, out _))
                    return false;
 
                return true;
            }
        }
 
        public Property[] ToProperties(IXmppService XmppService)
        {
            List<Property> Properties = [];
 
            AddProperty(Properties, Constants.XmppProperties.FirstName, this.FirstName);
            AddProperty(Properties, Constants.XmppProperties.MiddleNames, this.MiddleNames);
            AddProperty(Properties, Constants.XmppProperties.LastNames, this.LastNames);
            AddProperty(Properties, Constants.XmppProperties.PersonalNumber, this.PersonalNumber);
            AddProperty(Properties, Constants.XmppProperties.Address, this.Address);
            AddProperty(Properties, Constants.XmppProperties.Address2, this.Address2);
            AddProperty(Properties, Constants.XmppProperties.ZipCode, this.ZipCode);
            AddProperty(Properties, Constants.XmppProperties.Area, this.Area);
            AddProperty(Properties, Constants.XmppProperties.City, this.City);
            AddProperty(Properties, Constants.XmppProperties.Region, this.Region);
            AddProperty(Properties, Constants.XmppProperties.Country, ISO_3166_1.ToCode(this.CountryCode));
            AddProperty(Properties, Constants.XmppProperties.Nationality, ISO_3166_1.ToCode(this.NationalityCode));
            AddProperty(Properties, Constants.XmppProperties.Gender, this.GenderCode);
 
            if (this.NullIfInvalidBirthDate.HasValue)
            {
                AddProperty(Properties, Constants.XmppProperties.BirthDay, this.NullIfInvalidBirthDate.Value.Day.ToString(CultureInfo.InvariantCulture));
                AddProperty(Properties, Constants.XmppProperties.BirthMonth, this.NullIfInvalidBirthDate.Value.Month.ToString(CultureInfo.InvariantCulture));
                AddProperty(Properties, Constants.XmppProperties.BirthYear, this.NullIfInvalidBirthDate.Value.Year.ToString(CultureInfo.InvariantCulture));
            }
 
            AddProperty(Properties, Constants.XmppProperties.OrgName, this.OrgName);
            AddProperty(Properties, Constants.XmppProperties.OrgNumber, this.OrgNumber);
            AddProperty(Properties, Constants.XmppProperties.OrgDepartment, this.OrgDepartment);
            AddProperty(Properties, Constants.XmppProperties.OrgRole, this.OrgRole);
            AddProperty(Properties, Constants.XmppProperties.OrgAddress, this.OrgAddress);
            AddProperty(Properties, Constants.XmppProperties.OrgAddress2, this.OrgAddress2);
            AddProperty(Properties, Constants.XmppProperties.OrgZipCode, this.OrgZipCode);
            AddProperty(Properties, Constants.XmppProperties.OrgArea, this.OrgArea);
            AddProperty(Properties, Constants.XmppProperties.OrgCity, this.OrgCity);
            AddProperty(Properties, Constants.XmppProperties.OrgRegion, this.OrgRegion);
            AddProperty(Properties, Constants.XmppProperties.OrgCountry, ISO_3166_1.ToCode(this.OrgCountryCode));
            AddProperty(Properties, Constants.XmppProperties.Phone, this.PhoneNr);
            AddProperty(Properties, Constants.XmppProperties.EMail, this.EMail);
            AddProperty(Properties, Constants.XmppProperties.DeviceId, this.DeviceId);
            AddProperty(Properties, Constants.XmppProperties.Jid, XmppService.BareJid);
 
            return [.. Properties];
        }
 
        private static void AddProperty(List<Property> Properties, string PropertyName, string? PropertyValue)
        {
            string? s = PropertyValue?.Trim();
 
            if (!string.IsNullOrWhiteSpace(s))
                Properties.Add(new Property(PropertyName, s));
        }
 
        protected virtual Task SetProperties(LegalIdentity Identity, bool ClearPropertiesNotFound, bool SetPersonalProperties,
            bool SetOrganizationalProperties, bool SetAppProperties)
        {
            if (ClearPropertiesNotFound)
            {
                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.GenderCode = string.Empty;
                this.BirthDate = DateTime.Today;
                this.OrgName = string.Empty;
                this.OrgNumber = string.Empty;
                this.OrgAddress = string.Empty;
                this.OrgAddress2 = string.Empty;
                this.OrgZipCode = string.Empty;
                this.OrgArea = string.Empty;
                this.OrgCity = string.Empty;
                this.OrgRegion = string.Empty;
                this.OrgCountryCode = string.Empty;
                this.OrgDepartment = string.Empty;
                this.OrgRole = string.Empty;
                this.PhoneNr = string.Empty;
                this.EMail = string.Empty;
                this.DeviceId = string.Empty;
                this.Jid = string.Empty;
            }
 
            int? BirthDay = null;
            int? BirthMonth = null;
            int? BirthYear = null;
 
            foreach (Property P in Identity.Properties)
            {
                switch (P.Name)
                {
                    case Constants.XmppProperties.FirstName:
                        if (SetPersonalProperties)
                            this.FirstName = P.Value;
                        break;
 
                    case Constants.XmppProperties.MiddleNames:
                        if (SetPersonalProperties)
                            this.MiddleNames = P.Value;
                        break;
 
                    case Constants.XmppProperties.LastNames:
                        if (SetPersonalProperties)
                            this.LastNames = P.Value;
                        break;
 
                    case Constants.XmppProperties.PersonalNumber:
                        if (SetPersonalProperties)
                            this.PersonalNumber = P.Value;
                        break;
 
                    case Constants.XmppProperties.Address:
                        if (SetPersonalProperties)
                            this.Address = P.Value;
                        break;
 
                    case Constants.XmppProperties.Address2:
                        if (SetPersonalProperties)
                            this.Address2 = P.Value;
                        break;
 
                    case Constants.XmppProperties.ZipCode:
                        if (SetPersonalProperties)
                            this.ZipCode = P.Value;
                        break;
 
                    case Constants.XmppProperties.Area:
                        if (SetPersonalProperties)
                            this.Area = P.Value;
                        break;
 
                    case Constants.XmppProperties.City:
                        if (SetPersonalProperties)
                            this.City = P.Value;
                        break;
 
                    case Constants.XmppProperties.Region:
                        if (SetPersonalProperties)
                            this.Region = P.Value;
                        break;
 
                    case Constants.XmppProperties.Country:
                        if (SetPersonalProperties)
                            this.CountryCode = P.Value;
                        break;
 
                    case Constants.XmppProperties.Nationality:
                        if (SetPersonalProperties)
                            this.NationalityCode = P.Value;
                        break;
 
                    case Constants.XmppProperties.Gender:
                        if (SetPersonalProperties)
                            this.GenderCode = P.Value;
                        break;
 
                    case Constants.XmppProperties.BirthDay:
                        if (int.TryParse(P.Value, out int i))
                            BirthDay = i;
                        break;
 
                    case Constants.XmppProperties.BirthMonth:
                        if (int.TryParse(P.Value, out i))
                            BirthMonth = i;
                        break;
 
                    case Constants.XmppProperties.BirthYear:
                        if (int.TryParse(P.Value, out i))
                            BirthYear = i;
                        break;
 
                    case Constants.XmppProperties.OrgName:
                        if (SetOrganizationalProperties)
                            this.OrgName = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgNumber:
                        if (SetOrganizationalProperties)
                            this.OrgNumber = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgRole:
                        if (SetOrganizationalProperties)
                            this.OrgRole = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgDepartment:
                        if (SetOrganizationalProperties)
                            this.OrgDepartment = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgAddress:
                        if (SetOrganizationalProperties)
                            this.OrgAddress = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgAddress2:
                        if (SetOrganizationalProperties)
                            this.OrgAddress2 = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgZipCode:
                        if (SetOrganizationalProperties)
                            this.OrgZipCode = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgArea:
                        if (SetOrganizationalProperties)
                            this.OrgArea = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgCity:
                        if (SetOrganizationalProperties)
                            this.OrgCity = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgRegion:
                        if (SetOrganizationalProperties)
                            this.OrgRegion = P.Value;
                        break;
 
                    case Constants.XmppProperties.OrgCountry:
                        if (SetOrganizationalProperties)
                            this.OrgCountryCode = P.Value;
                        break;
 
                    case Constants.XmppProperties.DeviceId:
                        this.DeviceId = P.Value;
                        break;
 
                    case Constants.XmppProperties.Jid:
                        this.Jid = P.Value;
                        break;
 
                    case Constants.XmppProperties.Phone:
                        this.PhoneNr = P.Value;
                        break;
 
                    case Constants.XmppProperties.EMail:
                        this.EMail = P.Value;
                        break;
                }
            }
 
            if (SetPersonalProperties && BirthDay.HasValue && BirthMonth.HasValue && BirthYear.HasValue)
            {
                try
                {
                    this.BirthDate = new DateTime(BirthYear.Value, BirthMonth.Value, BirthDay.Value);
                }
                catch (Exception ex)
                {
                    ServiceRef.LogService.LogException(ex);
                    this.BirthDate = DateTime.Today;
                }
            }
 
            if (SetAppProperties)
            {
                this.DeviceId = ServiceRef.PlatformSpecific.GetDeviceId();
                this.Jid = ServiceRef.XmppService.BareJid;
                this.PhoneNr = ServiceRef.TagProfile.PhoneNumber;
                this.EMail = ServiceRef.TagProfile.EMail;
            }
 
            return Task.CompletedTask;
        }
 
        public virtual bool CanExecuteCommands => !this.IsBusy;
 
        public virtual bool CanApply => false;
 
        [RelayCommand(CanExecute = nameof(CanApply))]
        protected virtual Task Apply()
        {
            return Task.CompletedTask; // Do nothing by default.
        }
 
    }
}