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 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>();
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();
}
}
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();
}
}
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 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();
}
}
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 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 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 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
{
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 ModalDialogService.CancelAsync();
}
}
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);
SetLoadFailed(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 ModalDialogService.CancelAsync();
}
}
private async Task DeleteAdminAsync()
{
if (DataTableService.Entities.Count == 1)
{
return;
}
RenderFragment body = (builder) =>
{
builder.OpenComponent(0, typeof(DeleteAdministrator));
builder.AddAttribute(1, nameof(DeleteAdministrator.ApplicationUserId), DataTableService.SelectedEntity.Id);
builder.CloseComponent();
};
var instance = await ModalDialogService.ShowAsync("Delete Administrator", body, ModalDialogSize.Default);
var result = await instance.Result;
if (result.Succeeded)
{
await DataTableService.LoadTableDataAsync();
await SynchronizationService.UpdateAdministrators(PageId);
}
}
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 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
{
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 OpenDialogRemoveHardwareVaultAsync(HardwareVault hardwareVault)
{
if (!await VerifyAdUserAsync())
{
return;
}
RenderFragment body = (builder) =>
{
builder.OpenComponent(0, typeof(DeleteHardwareVault));
builder.AddAttribute(1, nameof(DeleteHardwareVault.HardwareVaultId), hardwareVault.Id);
builder.CloseComponent();
};
var instance = await ModalDialogService.ShowAsync("Delete hardware vault", body);
var result = await instance.Result;
if (result.Succeeded)
{
await LoadEmployeeAsync();
await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId);
}
}
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 OpenDialogAddSharedAccountAsync()
{
if (!await VerifyAdUserAsync())
{
return;
}
RenderFragment body = (builder) =>
{
builder.OpenComponent(0, typeof(AddSharedAccount));
builder.AddAttribute(1, nameof(AddSharedAccount.EmployeeId), EmployeeId);
builder.CloseComponent();
};
var instance = await ModalDialogService.ShowAsync("Add shared account", body, ModalDialogSize.Large);
var result = await instance.Result;
if (result.Succeeded)
{
await LoadEmployeeAsync();
await DataTableService.LoadTableDataAsync();
await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId);
}
}
protected override async Task OnInitializedAsync()
{
try
{
HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();
AccessProfile = await HardwareVaultService.GetProfileByIdAsync(HardwareVaultProfileId);
if (AccessProfile == null)
{
throw new Exception("Hardware Vault Profile not found.");
}
EntityBeingEdited = MemoryCache.TryGetValue(AccessProfile.Id, out object _);
if (!EntityBeingEdited)
{
MemoryCache.Set(AccessProfile.Id, AccessProfile);
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CancelAsync();
}
}
private async Task OpenDialogDeleteAccountAsync()
{
if (!await VerifyAdUserAsync())
{
return;
}
RenderFragment body = (builder) =>
{
builder.OpenComponent(0, typeof(DeleteAccount));
builder.AddAttribute(1, nameof(DeleteAccount.AccountId), DataTableService.SelectedEntity.Id);
builder.CloseComponent();
};
var instance = await ModalDialogService.ShowAsync("Delete Account", body);
var result = await instance.Result;
if (result.Succeeded)
{
await DataTableService.LoadTableDataAsync();
await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId);
}
}
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();
}
}
private async Task OpenModalDisableSsoAsync()
{
if (!await VerifyAdUserAsync())
{
return;
}
RenderFragment body = (builder) =>
{
builder.OpenComponent(0, typeof(EmployeeDisableSso));
builder.AddAttribute(1, nameof(EmployeeDisableSso.Employee), Employee);
builder.CloseComponent();
};
var instance = await ModalDialogService.ShowAsync("Disable SSO", body);
var result = await instance.Result;
if (result.Succeeded)
{
await LoadEmployeeSsoState();
await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId);
}
}
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();
}
}
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
{
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
{
EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>();
AccountService = ScopedServices.GetRequiredService <IAccountService>();
LdapService = ScopedServices.GetRequiredService <ILdapService>();
RemoteDeviceConnectionsService = ScopedServices.GetRequiredService <IRemoteDeviceConnectionsService>();
Account = await AccountService.GetAccountByIdAsync(AccountId);
if (Account == null)
{
throw new Exception("Account not found.");
}
EntityBeingEdited = MemoryCache.TryGetValue(Account.Id, out object _);
if (!EntityBeingEdited)
{
MemoryCache.Set(Account.Id, Account);
}
LdapSettings = await AppSettingsService.GetLdapSettingsAsync();
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(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();
}
}
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 SynchronizationService.UpdateEmployeeDetails(ExceptPageId, Account.EmployeeId);
await ModalDialogService.CloseAsync();
});
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CloseAsync();
}
}
