ChangePasswordViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Authentication;
using NeuroAccessMaui.Services.Tag;
using Waher.Networking.XMPP;
 
namespace NeuroAccessMaui.UI.Pages.Main.ChangePassword
{
    public partial class ChangePasswordViewModel : XmppViewModel
    {
        private readonly IAuthenticationService authenticationService = ServiceRef.Provider.GetRequiredService<IAuthenticationService>();
 
        public ChangePasswordViewModel()
            : base()
        {
        }
 
        [ObservableProperty]
        [NotifyCanExecuteChangedFor(nameof(ChangePasswordCommand))]
        private string oldPassword = string.Empty;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(IsPassword1NotValid))]
        [NotifyPropertyChangedFor(nameof(IsPassword2NotValid))]
        [NotifyPropertyChangedFor(nameof(LocalizedValidationError))]
        [NotifyCanExecuteChangedFor(nameof(ChangePasswordCommand))]
        private string newPassword = string.Empty;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(IsPassword2NotValid))]
        [NotifyPropertyChangedFor(nameof(NewPasswordsMatch))]
        [NotifyCanExecuteChangedFor(nameof(ChangePasswordCommand))]
        private string newPassword2 = string.Empty;
 
        [ObservableProperty]
        [NotifyPropertyChangedFor(nameof(NewPasswordsMatch))]
        [NotifyCanExecuteChangedFor(nameof(ChangePasswordCommand))]
        private bool incorrectPasswordAlertShown = false;
 
        public bool CanChangePassword => this.NewPasswordStrength == PasswordStrength.Strong && this.NewPasswordMatchesRetypedNewPassword && this.IsConnected && !this.IsBusy;
 
        public PasswordStrength NewPasswordStrength => ServiceRef.TagProfile.ValidatePasswordStrength(this.NewPassword);
 
        public bool NewPasswordsMatch => string.IsNullOrEmpty(this.NewPassword) ? string.IsNullOrEmpty(this.NewPassword2) : string.Equals(this.NewPassword, this.NewPassword2, StringComparison.Ordinal);
 
        public bool IsPassword1NotValid => !string.IsNullOrEmpty(this.NewPassword) && this.NewPasswordStrength != PasswordStrength.Strong;
 
        public bool IsPassword2NotValid => !string.IsNullOrEmpty(this.NewPassword2) && !this.NewPasswordsMatch;
 
        public bool NewPasswordMatchesRetypedNewPassword => string.IsNullOrEmpty(this.NewPassword) ? string.IsNullOrEmpty(this.NewPassword2) : string.Equals(this.NewPassword, this.NewPassword2, StringComparison.Ordinal);
 
        public string LocalizedValidationError => GetLocalizedValidationError(this.NewPasswordStrength);
 
        public static string GetLocalizedValidationError(PasswordStrength PasswordStrength)
        {
            return PasswordStrength switch
            {
                PasswordStrength.NotEnoughDigitsLettersSigns => ServiceRef.Localizer[nameof(AppResources.PasswordWithNotEnoughDigitsLettersSigns), Constants.Security.MinPasswordSymbolsFromDifferentClasses],
 
                PasswordStrength.NotEnoughDigitsOrSigns => ServiceRef.Localizer[nameof(AppResources.PasswordWithNotEnoughDigitsOrSigns), Constants.Security.MinPasswordSymbolsFromDifferentClasses],
                PasswordStrength.NotEnoughLettersOrDigits => ServiceRef.Localizer[nameof(AppResources.PasswordWithNotEnoughLettersOrDigits), Constants.Security.MinPasswordSymbolsFromDifferentClasses],
                PasswordStrength.NotEnoughLettersOrSigns => ServiceRef.Localizer[nameof(AppResources.PasswordWithNotEnoughLettersOrSigns), Constants.Security.MinPasswordSymbolsFromDifferentClasses],
                PasswordStrength.TooManyIdenticalSymbols => ServiceRef.Localizer[nameof(AppResources.PasswordWithTooManyIdenticalSymbols), Constants.Security.MaxPasswordIdenticalSymbols],
                PasswordStrength.TooManySequencedSymbols => ServiceRef.Localizer[nameof(AppResources.PasswordWithTooManySequencedSymbols), Constants.Security.MaxPasswordSequencedSymbols],
                PasswordStrength.TooShort => ServiceRef.Localizer[nameof(AppResources.PasswordTooShort), Constants.Security.MinPasswordLength],
 
                PasswordStrength.ContainsAddress => ServiceRef.Localizer[nameof(AppResources.PasswordContainsAddress)],
                PasswordStrength.ContainsName => ServiceRef.Localizer[nameof(AppResources.PasswordContainsName)],
                PasswordStrength.ContainsPersonalNumber => ServiceRef.Localizer[nameof(AppResources.PasswordContainsPersonalNumber)],
                PasswordStrength.ContainsPhoneNumber => ServiceRef.Localizer[nameof(AppResources.PasswordContainsPhoneNumber)],
                PasswordStrength.ContainsEMail => ServiceRef.Localizer[nameof(AppResources.PasswordContainsEMail)],
                PasswordStrength.Strong => string.Empty,
                _ => throw new NotImplementedException()
            };
        }
 
        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);
 
                this.NotifyCommandsCanExecuteChanged();
            });
        }
 
        public override void SetIsBusy(bool IsBusy)
        {
            base.SetIsBusy(IsBusy);
            this.NotifyCommandsCanExecuteChanged();
        }
 
        private void NotifyCommandsCanExecuteChanged()
        {
            this.ChangePasswordCommand.NotifyCanExecuteChanged();
        }
 
        [RelayCommand(CanExecute = nameof(CanChangePassword))]
        private async Task ChangePassword()
        {
            if (!string.IsNullOrEmpty(this.OldPassword) && this.CanChangePassword)
            {
                if (await this.authenticationService.CheckPasswordAndUnblockUserAsync(this.OldPassword))
                {
                    try
                    {
                        string NewPassword = ServiceRef.CryptoService.CreateRandomPassword();
 
                        if (!await ServiceRef.XmppService.ChangePassword(NewPassword))
                        {
                            await ServiceRef.UiService.DisplayAlert(
                                ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                                ServiceRef.Localizer[nameof(AppResources.UnableToChangePassword)]);
                            return;
                        }
 
                        ServiceRef.TagProfile.LocalPassword = this.NewPassword;
                        ServiceRef.TagProfile.SetAccount(ServiceRef.TagProfile.Account!, NewPassword, string.Empty);
 
                        await ServiceRef.UiService.DisplayAlert(
                            ServiceRef.Localizer[nameof(AppResources.SuccessTitle)],
                            ServiceRef.Localizer[nameof(AppResources.PasswordChanged)]);
 
                        await this.GoBack();
                    }
                    catch (Exception ex)
                    {
                        ServiceRef.LogService.LogException(ex);
                        await ServiceRef.UiService.DisplayException(ex);
                    }
                }
                else
                {
                    this.OldPassword = string.Empty;
 
                    long PasswordAttemptCounter = await this.authenticationService.GetCurrentPasswordCounterAsync();
                    long RemainingAttempts = Math.Max(0, Constants.Password.FirstMaxPasswordAttempts - PasswordAttemptCounter);
 
                    await ServiceRef.UiService.DisplayAlert(
                        ServiceRef.Localizer[nameof(AppResources.ErrorTitle)],
                        ServiceRef.Localizer[nameof(AppResources.PasswordIsInvalid), RemainingAttempts]);
 
                    await this.authenticationService.CheckUserBlockingAsync();
                }
            }
        }
    }
}