private async Task EditAccountAsync() { try { await Button.SpinAsync(async() => { var vaults = await SharedAccountService.EditSharedAccountAsync(SharedAccountEditModel); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(vaults); await ToastService.ShowToastAsync("Shared account updated.", ToastType.Success); await ModalDialogClose(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Name), ex.Message); } catch (IncorrectUrlException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Urls), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task EditAccountOtpAsync() { try { await ButtonSpinner.SpinAsync(async() => { await EmployeeService.EditPersonalAccountOtpAsync(Account, _accountOtp); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(Account.EmployeeId)); await ToastService.ShowToastAsync("Account OTP updated.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, Account.EmployeeId); await ModalDialogService.CloseAsync(); }); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(AccountOtp.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task InviteAdminAsync() { try { await ButtonSpinner.SpinAsync(async() => { var callBakcUrl = await ApplicationUserService.InviteAdministratorAsync(Invitation.Email, NavigationManager.BaseUri); await EmailSenderService.SendUserInvitationAsync(Invitation.Email, callBakcUrl); await ToastService.ShowToastAsync("Administrator invited.", ToastType.Success); await SynchronizationService.UpdateAdministrators(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Invitation.Email), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task NextAsync() { try { await ButtonSpinner.SpinAsync(async() => { var user = await ApplicationUserService.GetUserByEmailAsync(UserEmailModel.Email); if (user == null) { ValidationErrorMessage.DisplayError(nameof(UserEmailModel.Email), HESException.GetMessage(HESCode.UserNotFound)); return; } PasswordSignInModel.Email = UserEmailModel.Email; HasSecurityKey = (await Fido2Service.GetCredentialsByUserEmail(UserEmailModel.Email)).Count > 0; AuthenticationStep = AuthenticationStep.EnterPassword; }); } catch (HESException ex) { ValidationErrorMessage.DisplayError(nameof(UserEmailModel.Email), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); SetErrorMessage(ex.Message); } }
private async Task EditAccoountOtpAsync() { try { await ButtonSpinner.SpinAsync(async() => { var vaults = await SharedAccountService.EditSharedAccountOtpAsync(Account, AccountOtp); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(vaults); await SynchronizationService.UpdateSharedAccounts(ExceptPageId); await ToastService.ShowToastAsync("Account OTP updated.", ToastType.Success); await ModalDialogService.CloseAsync(); }); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task CreateAccountAsync() { try { await ButtonSpinner.SpinAsync(async() => { await EmployeeService.CreatePersonalAccountAsync(PersonalAccount); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(EmployeeId)); await ToastService.ShowToastAsync("Account created.", ToastType.Success); await ModalDialogClose(); }); } catch (HESException ex) when(ex.Code == HESCode.AccountExist) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.Name), ex.Message); } catch (HESException ex) when(ex.Code == HESCode.IncorrectUrl) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.Urls), ex.Message); } catch (HESException ex) when(ex.Code == HESCode.IncorrectOtp) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task EditAsync() { try { await ButtonSpinner.SpinAsync(async() => { await OrgStructureService.EditDepartmentAsync(Department); await ToastService.ShowToastAsync("Department updated.", ToastType.Success); await Refresh.InvokeAsync(this); await SynchronizationService.UpdateOrgSructureCompanies(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Department.Name), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task CreateAccountAsync() { try { await ButtonSpinner.SpinAsync(async() => { await SharedAccountService.CreateSharedAccountAsync(SharedAccount); await ToastService.ShowToastAsync("Account created.", ToastType.Success); await SynchronizationService.UpdateSharedAccounts(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Name), ex.Message); } catch (IncorrectUrlException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Urls), ex.Message); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task CreateAccountAsync() { try { await ButtonSpinner.SpinAsync(async() => { await EmployeeService.CreatePersonalAccountAsync(PersonalAccount); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(EmployeeId)); await Refresh.InvokeAsync(this); await ToastService.ShowToastAsync("Account created.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, EmployeeId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.Name), ex.Message); } catch (IncorrectUrlException ex) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.Urls), ex.Message); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task EditTemplateAsync() { try { await Button.SpinAsync(async() => { await TemplateService.EditTemplateAsync(Template); await ToastService.ShowToastAsync("Template updated.", ToastType.Success); await ModalDialogClose(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Name), ex.Message); } catch (IncorrectUrlException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Urls), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task EditRenewLicenseOrderAsync() { try { await ButtonSpinner.SpinAsync(async() => { if (_renewLicenseOrder.EndDate < DateTime.Now) { ValidationErrorMessage.DisplayError(nameof(RenewLicenseOrder.EndDate), $"End Date must not be less than Start Date."); return; } if (!_renewLicenseOrder.HardwareVaults.Where(x => x.Checked).Any()) { ValidationErrorMessage.DisplayError(nameof(RenewLicenseOrder.HardwareVaults), $"Select at least one hardware vault."); return; } var checkedHardwareVaults = _renewLicenseOrder.HardwareVaults.Where(x => x.Checked).ToList(); var maxEndDate = checkedHardwareVaults.Select(x => x.LicenseEndDate).Max(); if (_renewLicenseOrder.EndDate < maxEndDate) { ValidationErrorMessage.DisplayError(nameof(RenewLicenseOrder.HardwareVaults), $"The selected End Date less than max end date for selected hardware vaults."); return; } LicenseOrder.ContactEmail = _renewLicenseOrder.ContactEmail; LicenseOrder.Note = _renewLicenseOrder.Note; LicenseOrder.ProlongExistingLicenses = true; LicenseOrder.StartDate = null; LicenseOrder.EndDate = _renewLicenseOrder.EndDate.Date; await LicenseService.EditOrderAsync(LicenseOrder, checkedHardwareVaults); await SynchronizationService.UpdateLicenses(ExceptPageId); await ToastService.ShowToastAsync("Order created.", ToastType.Success); await ModalDialogService.CloseAsync(); }); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task EditNewLicenseOrderAsync() { try { await Button.SpinAsync(async() => { if (_newLicenseOrder.StartDate < DateTime.Now.Date) { ValidationErrorMessage.DisplayError(nameof(NewLicenseOrder.StartDate), $"Start Date must be at least current date."); return; } if (_newLicenseOrder.EndDate < _newLicenseOrder.StartDate) { ValidationErrorMessage.DisplayError(nameof(NewLicenseOrder.EndDate), $"End Date must not be less than Start Date."); return; } if (!_newLicenseOrder.HardwareVaults.Where(x => x.Checked).Any()) { ValidationErrorMessage.DisplayError(nameof(NewLicenseOrder.HardwareVaults), $"Select at least one hardware vault."); return; } LicenseOrder.ContactEmail = _newLicenseOrder.ContactEmail; LicenseOrder.Note = _newLicenseOrder.Note; LicenseOrder.ProlongExistingLicenses = false; LicenseOrder.StartDate = _newLicenseOrder.StartDate.Date; LicenseOrder.EndDate = _newLicenseOrder.EndDate.Date; var checkedHardwareVaults = _newLicenseOrder.HardwareVaults.Where(x => x.Checked).ToList(); await LicenseService.EditOrderAsync(LicenseOrder, checkedHardwareVaults); await ToastService.ShowToastAsync("Order created.", ToastType.Success); await ModalDialogClose(); }); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task ChangeEmailAsync() { try { await ButtonChangeEmail.SpinAsync(async() => { await ApplicationUserService.ChangeEmailAsync(ChangeEmailModel); await ToastService.ShowToastAsync("Email confirmation sent.", ToastType.Success); }); } catch (HESException ex) { ValidationErrorMessage.DisplayError(nameof(ChangeEmailModel.NewEmail), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); } }
private async Task ActivateAsync() { try { await ButtonSpinner.SpinAsync(async() => { var result = await DataProtectionService.ActivateProtectionAsync(Input.Password); if (!result) { ValidationErrorMessage.DisplayError(nameof(InputModel.Password), "Invalid password"); return; } NavigationManager.NavigateTo(""); }); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); } }
private async Task EditAsync() { try { await ButtonSpinner.SpinAsync(async() => { await EmployeeService.EditEmployeeAsync(Employee); await ToastService.ShowToastAsync("Employee updated.", ToastType.Success); await ModalDialogClose(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Employee.FirstName), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task CreateAsync() { try { await Button.SpinAsync(async() => { await OrgStructureService.CreatePositionAsync(Position); await ToastService.ShowToastAsync("Position created.", ToastType.Success); await ModalDialogClose(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Position.Name), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task NextAsync() { try { await Button.SpinAsync(async() => { var user = await ApplicationUserService.GetUserByEmailAsync(UserEmailModel.Email); if (user == null) { ValidationErrorMessage.DisplayError(nameof(UserEmailModel.Email), HESException.GetMessage(HESCode.UserNotFound)); return; } await SignInWithSecurityKeyAsync(); }); } catch (Exception ex) { Logger.LogError(ex.Message); SetErrorMessage(ex.Message); } }
private async Task LoginWithPasswordAsync() { try { await ButtonSpinner.SpinAsync(async() => { var response = await IdentityApiClient.LoginWithPasswordAsync(PasswordSignInModel); response.ThrowIfFailed(); if (response.Succeeded) { NavigationManager.NavigateTo(Routes.Dashboard, true); return; } if (response.RequiresTwoFactor) { NavigationManager.NavigateTo($"{Routes.LoginWith2Fa}?returnUrl={ReturnUrl}", true); return; } if (response.IsLockedOut) { NavigationManager.NavigateTo(Routes.Lockout, true); return; } }); } catch (HESException ex) when(ex.Code == HESCode.InvalidLoginAttempt) { ValidationErrorMessage.DisplayError(nameof(PasswordSignInModel.Password), HESException.GetMessage(ex.Code)); } catch (Exception ex) { Logger.LogError(ex.Message); SetErrorMessage(ex.Message); } }
private async Task InviteAdminAsync() { try { await ButtonSpinner.SpinAsync(async() => { var callBakcUrl = await ApplicationUserService.InviteAdministratorAsync(Invitation.Email, NavigationManager.BaseUri); await EmailSenderService.SendUserInvitationAsync(Invitation.Email, callBakcUrl); await ToastService.ShowToastAsync("Administrator invited.", ToastType.Success); await ModalDialogClose(); }); } catch (HESException ex) when(ex.Code == HESCode.EmailAlreadyTaken) { ValidationErrorMessage.DisplayError(nameof(Invitation.Email), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task EditAsync() { try { await ButtonSpinner.SpinAsync(async() => { await GroupService.EditGroupAsync(Group); await ToastService.ShowToastAsync("Group updated.", ToastType.Success); await SynchronizationService.UpdateGroups(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Core.Entities.Group.Name), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }