protected override async Task OnInitializedAsync() { try { EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>(); HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>(); RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>(); HardwareVault = await HardwareVaultService.GetVaultByIdAsync(HardwareVaultId); if (HardwareVault == null) { throw new HESException(HESCode.HardwareVaultNotFound); } EntityBeingEdited = MemoryCache.TryGetValue(HardwareVault.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(HardwareVault.Id, HardwareVault); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
protected override async Task OnInitializedAsync() { try { LdapService = ScopedServices.GetRequiredService <ILdapService>(); GroupService = ScopedServices.GetRequiredService <IGroupService>(); LdapSettings = await AppSettingsService.GetLdapSettingsAsync(); if (LdapSettings == null) { ActiveDirectoryInitialization = ActiveDirectoryInitialization.HostNotSet; } else if (LdapSettings?.Host != null && LdapSettings?.UserName == null && LdapSettings?.Password == null) { ActiveDirectoryInitialization = ActiveDirectoryInitialization.CredentialsNotSet; } else { await GetGroups(LdapSettings); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
protected override async Task OnInitializedAsync() { try { Department = await OrgStructureService.GetDepartmentByIdAsync(DepartmentId); if (Department == null) { throw new Exception("Department not found."); } EntityBeingEdited = MemoryCache.TryGetValue(Department.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Department.Id, Department); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
protected override async Task OnInitializedAsync() { try { HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>(); HardwareVault = await HardwareVaultService.GetVaultByIdAsync(HardwareVaultId); if (HardwareVault == null) { throw new Exception("HardwareVault not found."); } EntityBeingEdited = MemoryCache.TryGetValue(HardwareVault.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(HardwareVault.Id, HardwareVault); } } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task EditAccountPasswordAsync() { try { await ButtonSpinner.SpinAsync(async() => { using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await EmployeeService.EditPersonalAccountPwdAsync(Account, AccountPassword); if (AccountPassword.UpdateActiveDirectoryPassword) { await LdapService.SetUserPasswordAsync(Account.EmployeeId, AccountPassword.Password, LdapSettings); } transactionScope.Complete(); } RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(Account.EmployeeId)); await ToastService.ShowToastAsync("Account password updated.", ToastType.Success); await ModalDialogClose(); }); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogClose(); } }
public async Task AddAsync() { try { if (!Employees.Any(x => x.Value == true)) { _notSelected = true; return; } var employeeIds = Employees.Where(x => x.Value).Select(x => x.Key.Id).ToList(); await GroupService.AddEmployeesToGroupAsync(employeeIds, GroupId); await ToastService.ShowToastAsync("Employee added.", ToastType.Success); //await SynchronizationService.UpdateGroupDetails(ExceptPageId, GroupId); //await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); //await ModalDialogService.CloseAsync(); } }
protected override async Task OnInitializedAsync() { try { SharedAccountService = ScopedServices.GetRequiredService <ISharedAccountService>(); RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>(); ModalDialogService.OnCancel += OnCancelAsync; Account = await SharedAccountService.GetSharedAccountByIdAsync(AccountId); if (Account == null) { throw new Exception("Account not found"); } EntityBeingEdited = MemoryCache.TryGetValue(Account.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Account.Id, Account); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task AddAsync() { try { if (!Users.Any(x => x.Checked)) { WarningMessage = "Please select at least one user."; return; } await LdapService.AddUsersAsync(Users.Where(x => x.Checked).ToList(), CreateAccounts, CreateGroups); await ToastService.ShowToastAsync("Employee imported.", ToastType.Success); //await HubContext.Clients.AllExcept(ConnectionId).SendAsync(RefreshPage.Employees); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task <bool> VerifyAdUserAsync() { try { await LdapService.VerifyAdUserAsync(Employee); return(true); } catch (HESException ex) when(ex.Code == HESCode.ActiveDirectoryUserNotFound) { await EmployeeService.RemoveFromHideezKeyOwnersAsync(Employee.Id); Employee = await EmployeeService.GetEmployeeByIdAsync(EmployeeId, asNoTracking : true); await ToastService.ShowToastAsync(ex.Message, ToastType.Notify); return(false); } catch (LdapException ex) when(ex.ResultCode == (LdapForNet.Native.Native.ResultCode) 81) { await ToastService.ShowToastAsync("The LDAP server is unavailable.", ToastType.Error); return(false); } catch (Exception ex) { await ToastService.ShowToastAsync(ex.Message, ToastType.Error); return(false); } }
protected override async Task OnInitializedAsync() { try { EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>(); TemplateService = ScopedServices.GetRequiredService <ITemplateService>(); LdapService = ScopedServices.GetRequiredService <ILdapService>(); RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>(); Employee = await EmployeeService.GetEmployeeByIdAsync(EmployeeId); Templates = await TemplateService.GetTemplatesAsync(); PersonalAccount = new AccountAddModel() { EmployeeId = EmployeeId }; SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
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(); } }
protected override async Task OnInitializedAsync() { try { HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>(); RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>(); HardwareVault = await HardwareVaultService.GetVaultByIdAsync(HardwareVaultId); if (HardwareVault == null) { throw new Exception("HardwareVault not found."); } EntityBeingEdited = MemoryCache.TryGetValue(HardwareVault.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(HardwareVault.Id, HardwareVault); } VaultProfiles = new SelectList(await HardwareVaultService.GetProfilesAsync(), nameof(HardwareVaultProfile.Id), nameof(HardwareVaultProfile.Name)); SelectedVaultProfileId = VaultProfiles.First().Value; SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
private async Task AddVaultAsync() { try { if (SelectedHardwareVault == null) { WarningMessage = "Please, select a vault."; return; } await WorkstationService.AddProximityVaultAsync(WorkstationId, SelectedHardwareVault.Id); await RemoteWorkstationConnectionsService.UpdateProximitySettingsAsync(WorkstationId, await WorkstationService.GetProximitySettingsAsync(WorkstationId)); await ToastService.ShowToastAsync("Vault added", ToastType.Success); await SynchronizationService.UpdateWorkstationDetails(ExceptPageId, WorkstationId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message, ex); 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 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(); } }
protected override async Task OnInitializedAsync() { try { Company = await OrgStructureService.GetCompanyByIdAsync(CompanyId); if (Company == null) { throw new Exception("Company not found."); } EntityBeingEdited = MemoryCache.TryGetValue(Company.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Company.Id, Company); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
protected override async Task OnInitializedAsync() { try { TemplateService = ScopedServices.GetRequiredService <ITemplateService>(); Template = await TemplateService.GetByIdAsync(TemplateId); if (Template == null) { throw new Exception("Template not found."); } EntityBeingEdited = MemoryCache.TryGetValue(Template.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Template.Id, Template); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
protected override async Task OnInitializedAsync() { try { GroupService = ScopedServices.GetRequiredService <IGroupService>(); Group = await GroupService.GetGroupByIdAsync(GroupId); if (Group == null) { throw new Exception("Group not found"); } EntityBeingEdited = MemoryCache.TryGetValue(Group.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Group.Id, Group); } } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task AddSharedAccoountAsync() { try { var account = await EmployeeService.AddSharedAccountAsync(EmployeeId, SelectedSharedAccount.Id); var employee = await EmployeeService.GetEmployeeByIdAsync(account.EmployeeId); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(employee.HardwareVaults.Select(x => x.Id).ToArray()); await Refresh.InvokeAsync(this); await ToastService.ShowToastAsync("Account added and will be recorded when the device is connected to the server.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, EmployeeId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { await ModalDialogService.CloseAsync(); Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); } }
private async Task ResetAuthenticatorKeyAsync() { try { var response = await HttpClient.PostAsync("api/Identity/ResetAuthenticatorKey", new StringContent(string.Empty)); if (!response.IsSuccessStatusCode) { throw new Exception(await response.Content.ReadAsStringAsync()); } await Refresh.InvokeAsync(); await ToastService.ShowToastAsync("Your authenticator app key has been reset, you will need to configure your authenticator app using the new key.", ToastType.Success); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
protected override async Task OnInitializedAsync() { try { ModalDialogService.OnCancel += ModalDialogService_OnCancel; Position = await OrgStructureService.GetPositionByIdAsync(PositionId); if (Position == null) { throw new Exception("Position not found."); } EntityBeingEdited = MemoryCache.TryGetValue(Position.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Position.Id, Position); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
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 DisableAlarmAsync() { try { var checkPassword = await UserManager.CheckPasswordAsync(ApplicationUser, UserConfirmPassword); if (!checkPassword) { throw new Exception("Invalid password"); } await RemoteWorkstationConnections.UnlockAllWorkstationsAsync(ApplicationUser.Email); await SynchronizationService.UpdateAlarm(ExceptPageId); await CallBack.InvokeAsync(this); await ToastService.ShowToastAsync("All workstations are unlocked.", ToastType.Success); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
protected override async Task OnInitializedAsync() { try { EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>(); LdapService = ScopedServices.GetRequiredService <ILdapService>(); RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>(); Account = await EmployeeService.GetAccountByIdAsync(AccountId); if (Account == null) { throw new HESException(HESCode.AccountNotFound); } EntityBeingEdited = MemoryCache.TryGetValue(Account.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Account.Id, Account); } Employee = await EmployeeService.GetEmployeeByIdAsync(Account.EmployeeId); LdapSettings = await AppSettingsService.GetLdapSettingsAsync(); SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); 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 AddAsync() { try { if (!Groups.Any(x => x.Checked)) { WarningMessage = "Please select at least one group."; return; } await LdapService.AddGroupsAsync(Groups.Where(x => x.Checked).ToList(), CreateEmployees); await ToastService.ShowToastAsync("Groups added.", ToastType.Success); await SynchronizationService.UpdateGroups(ExceptPageId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
protected override async Task OnInitializedAsync() { try { LicenseService = ScopedServices.GetRequiredService <ILicenseService>(); LicenseOrder = await LicenseService.GetLicenseOrderByIdAsync(LicenseOrderId); if (LicenseOrder == null) { throw new Exception("License Order not found."); } EntityBeingEdited = MemoryCache.TryGetValue(LicenseOrder.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(LicenseOrder.Id, LicenseOrder); } } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
protected override async Task OnInitializedAsync() { try { LicenseService = ScopedServices.GetRequiredService <ILicenseService>(); HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>(); _newLicenseOrder = new NewLicenseOrder() { HardwareVaults = await HardwareVaultService.GetVaultsWithoutLicenseAsync() }; _renewLicenseOrder = new RenewLicenseOrder() { HardwareVaults = await HardwareVaultService.GetVaultsWithLicenseAsync() }; SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
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(); } }
protected override async Task OnInitializedAsync() { try { WorkstationService = ScopedServices.GetRequiredService <IWorkstationService>(); RemoteWorkstationConnectionsService = ScopedServices.GetRequiredService <IRemoteWorkstationConnectionsService>(); Workstation = await WorkstationService.GetWorkstationByIdAsync(WorkstationId); if (Workstation == null) { throw new Exception("Workstation not found."); } EntityBeingEdited = MemoryCache.TryGetValue(Workstation.Id, out object _); if (!EntityBeingEdited) { MemoryCache.Set(Workstation.Id, Workstation); } SetInitialized(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogCancel(); } }
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(); } }