private async Task SetAsWorkstationAccountAsync()
{
try
{
await EmployeeService.SetAsPrimaryAccountAsync(Account.Employee.Id, Account.Id);
var employee = await EmployeeService.GetEmployeeByIdAsync(Account.Employee.Id);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(employee.Id));
await Refresh.InvokeAsync(this);
await ToastService.ShowToastAsync("Account setted as primary.", ToastType.Success);
await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, Account.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 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 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();
}
}
private async Task GenerateAccountPasswordAsync()
{
try
{
if (LdapSettings?.Password == null)
{
throw new Exception("Active Directory credentials not set in parameters page.");
}
var accountPassword = new AccountPassword()
{
Password = PasswordGenerator.Generate()
};
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await EmployeeService.EditPersonalAccountPwdAsync(Account, accountPassword);
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 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();
}
}
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 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 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);
}
}
public async Task DeleteVaultAsync()
{
try
{
var employeeId = HardwareVault.EmployeeId;
await EmployeeService.RemoveHardwareVaultAsync(HardwareVault.Id, Reason, IsNeedBackup);
await Refresh.InvokeAsync(this);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultStatus(HardwareVault.Id);
await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, employeeId);
await SynchronizationService.HardwareVaultStateChanged(HardwareVault.Id);
await ToastService.ShowToastAsync("Vault removed.", ToastType.Success);
await ModalDialogService.CloseAsync();
}
catch (Exception ex)
{
Logger.LogError(ex.Message, ex);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CancelAsync();
}
}
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 DeleteAccoountAsync()
{
try
{
var vaults = await SharedAccountService.DeleteSharedAccountAsync(Account.Id);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(vaults);
await ToastService.ShowToastAsync("Account deleted.", ToastType.Success);
await ModalDialogClose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
private async Task ChangeProfileAsync()
{
try
{
await HardwareVaultService.ChangeVaultProfileAsync(HardwareVault.Id, SelectedVaultProfileId);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(HardwareVault.Id);
await ToastService.ShowToastAsync("Vault profile updated", ToastType.Success);
await ModalDialogClose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
private async Task DeleteAccoountAsync()
{
try
{
var account = await EmployeeService.DeleteAccountAsync(Account.Id);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(account.EmployeeId));
await ToastService.ShowToastAsync("Account deleted.", ToastType.Success);
await ModalDialogClose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message, ex);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
private async Task ChangeStatusAsync()
{
try
{
switch (VaultStatus)
{
case VaultStatus.Active:
await HardwareVaultService.ActivateVaultAsync(HardwareVault.Id);
await ToastService.ShowToastAsync("Vault pending activate.", ToastType.Success);
break;
case VaultStatus.Suspended:
await HardwareVaultService.SuspendVaultAsync(HardwareVault.Id, StatusDescription);
await ToastService.ShowToastAsync("Vault pending suspend.", ToastType.Success);
break;
case VaultStatus.Compromised:
if (CompromisedIsDisabled)
{
return;
}
await HardwareVaultService.VaultCompromisedAsync(HardwareVault.Id, StatusReason, StatusDescription);
await ToastService.ShowToastAsync("Vault compromised.", ToastType.Success);
break;
}
await SynchronizationService.UpdateHardwareVaults(ExceptPageId);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultStatus(HardwareVault.Id);
await ModalDialogService.CloseAsync();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CancelAsync();
}
}
private async Task EditAccoountPasswordAsync()
{
try
{
await Button.SpinAsync(async() =>
{
var vaults = await SharedAccountService.EditSharedAccountPwdAsync(Account, AccountPassword);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(vaults);
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 ModalDialogCancel();
}
}
private async Task SetAsWorkstationAccountAsync()
{
try
{
await EmployeeService.SetAsPrimaryAccountAsync(Account.Employee.Id, Account.Id);
var employee = await EmployeeService.GetEmployeeByIdAsync(Account.Employee.Id);
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(employee.Id));
await ToastService.ShowToastAsync("Account setted as primary.", ToastType.Success);
await ModalDialogClose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message, ex);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
private async Task CreateAsync()
{
try
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await EmployeeService.CreateEmployeeAsync(Employee);
if (SelectedHardwareVault != null)
{
await EmployeeService.AddHardwareVaultAsync(Employee.Id, SelectedHardwareVault.Id);
}
if (!AccountSkiped)
{
if (AccountType == AccountType.Personal)
{
await EmployeeService.CreatePersonalAccountAsync(PersonalAccount);
}
else
{
await EmployeeService.AddSharedAccountAsync(Employee.Id, SharedAccountId);
}
}
transactionScope.Complete();
}
if (SelectedHardwareVault != null)
{
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(SelectedHardwareVault.Id);
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CloseAsync();
}
}
