ChangePasswordViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using NeuroAccessMaui.Resources.Languages;
using NeuroAccessMaui.Services;
using NeuroAccessMaui.Services.Tag;
using NeuroAccessMaui.UI.Pages.Registration.Views;
using Waher.Networking.XMPP;
 
namespace NeuroAccessMaui.UI.Pages.Main.ChangePassword
{
    public partial class ChangePasswordViewModel : XmppViewModel
    {
        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 => DefinePasswordViewModel.GetLocalizedValidationError(this.NewPasswordStrength);
 
        protected override async Task OnInitialize()
        {
            await base.OnInitialize();
            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 App.CheckPasswordAndUnblockUser(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 App.GetCurrentPasswordCounter();
                    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 App.CheckUserBlocking();
                }
            }
        }
    }
}