protected override async Task OnInitializedAsync()
{
try
{
ApplicationUserService = ScopedServices.GetRequiredService <IApplicationUserService>();
EmailSenderService = ScopedServices.GetRequiredService <IEmailSenderService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <ApplicationUser, ApplicationUserFilter> >();
SynchronizationService.UpdateAdministratorsPage += UpdateAdministratorsPage;
SynchronizationService.UpdateAdministratorStatePage += UpdateAdministratorStatePage;
AuthenticationState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
await BreadcrumbsService.SetAdministrators();
await DataTableService.InitializeAsync(ApplicationUserService.GetAdministratorsAsync, ApplicationUserService.GetAdministratorsCountAsync, StateHasChanged, nameof(ApplicationUser.Email), ListSortDirection.Ascending);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
DashboardService = ScopedServices.GetRequiredService <IDashboardService>();
await BreadcrumbsService.SetDashboard();
ServerdCard = await DashboardService.GetServerCardAsync();
ServerdCard.RightAction = ShowHardwareVaultTaskAsync;
if (ServerdCard.Notifications.FirstOrDefault(x => x.Page == "long-pending-tasks") != null)
{
ServerdCard.Notifications.FirstOrDefault(x => x.Page == "long-pending-tasks").Action = ShowHardwareVaultTaskAsync;
}
EmployeesCard = await DashboardService.GetEmployeesCardAsync();
HardwareVaultsCard = await DashboardService.GetHardwareVaultsCardAsync();
WorkstationsCard = await DashboardService.GetWorkstationsCardAsync();
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
WorkstationAuditService = ScopedServices.GetRequiredService <IWorkstationAuditService>();
MainTableService = ScopedServices.GetRequiredService <IMainTableService <WorkstationSession, WorkstationSessionFilter> >();
switch (DashboardFilter)
{
case "NonHideezUnlock":
MainTableService.DataLoadingOptions.Filter.UnlockedBy = Hideez.SDK.Communication.SessionSwitchSubject.NonHideez;
break;
case "LongOpenSession":
MainTableService.DataLoadingOptions.Filter.Query = WorkstationAuditService.SessionQuery().Where(x => x.StartDate <= DateTime.UtcNow.AddHours(-12) && x.EndDate == null);
break;
case "OpenedSessions":
MainTableService.DataLoadingOptions.Filter.Query = WorkstationAuditService.SessionQuery().Where(x => x.EndDate == null);
break;
}
await BreadcrumbsService.SetAuditWorkstationSessions();
await MainTableService.InitializeAsync(WorkstationAuditService.GetWorkstationSessionsAsync, WorkstationAuditService.GetWorkstationSessionsCountAsync, ModalDialogService, StateHasChanged, nameof(WorkstationSession.StartDate), ListSortDirection.Descending);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
WorkstationService = ScopedServices.GetRequiredService <IWorkstationService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <Workstation, WorkstationFilter> >();
SynchronizationService.UpdateWorkstationsPage += UpdateWorkstationsPage;
switch (DashboardFilter)
{
case "NotApproved":
DataTableService.DataLoadingOptions.Filter.Approved = false;
break;
case "Online":
//TODO
break;
}
await BreadcrumbsService.SetWorkstations();
await DataTableService.InitializeAsync(WorkstationService.GetWorkstationsAsync, WorkstationService.GetWorkstationsCountAsync, StateHasChanged, nameof(Workstation.Name));
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>();
AppSettingsService = ScopedServices.GetRequiredService <IAppSettingsService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <Account, AccountFilter> >();
LdapService = ScopedServices.GetRequiredService <ILdapService>();
SynchronizationService.UpdateEmployeeDetailsPage += UpdateEmployeeDetailsPage;
SynchronizationService.UpdateHardwareVaultState += UpdateHardwareVaultState;
await LoadEmployeeAsync();
await BreadcrumbsService.SetEmployeeDetails(Employee?.FullName);
await LoadLdapSettingsAsync();
await DataTableService.InitializeAsync(EmployeeService.GetAccountsAsync, EmployeeService.GetAccountsCountAsync, StateHasChanged, nameof(Account.Name), entityId : EmployeeId);
await LoadEmployeeSsoState();
SetInitialized();
}
catch (Exception ex)
{
SetLoadFailed(ex.Message);
Logger.LogError(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <HardwareVault, HardwareVaultFilter> >();
SynchronizationService.UpdateHardwareVaultsPage += UpdateHardwareVaultsPage;
SynchronizationService.UpdateHardwareVaultState += UpdateHardwareVaultState;
switch (DashboardFilter)
{
case "LowBattery":
DataTableService.DataLoadingOptions.Filter.Battery = "low";
break;
case "VaultLocked":
DataTableService.DataLoadingOptions.Filter.Status = VaultStatus.Locked;
break;
case "VaultReady":
DataTableService.DataLoadingOptions.Filter.Status = VaultStatus.Ready;
break;
case "LicenseWarning":
DataTableService.DataLoadingOptions.Filter.LicenseStatus = VaultLicenseStatus.Warning;
break;
case "LicenseCritical":
DataTableService.DataLoadingOptions.Filter.LicenseStatus = VaultLicenseStatus.Critical;
break;
case "LicenseExpired":
DataTableService.DataLoadingOptions.Filter.LicenseStatus = VaultLicenseStatus.Expired;
break;
}
await BreadcrumbsService.SetHardwareVaults();
await DataTableService.InitializeAsync(HardwareVaultService.GetVaultsAsync, HardwareVaultService.GetVaultsCountAsync, StateHasChanged, nameof(HardwareVault.Id));
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
SynchronizationService.UpdateDataProtectionPage += UpdateDataProtectionPage;
ProtectionStatus();
await BreadcrumbsService.SetDataProtection();
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
OrgStructureService = ScopedServices.GetRequiredService <IOrgStructureService>();
SynchronizationService.UpdateOrgSructureCompaniesPage += UpdateOrgSructureCompaniesPage;
await BreadcrumbsService.SetOrgStructure();
await LoadCompaniesAsync();
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
AppSettingsService = ScopedServices.GetRequiredService <IAppSettingsService>();
SynchronizationService.UpdateParametersPage += UpdateParametersPage;
await BreadcrumbsService.SetParameters();
await LoadDataSettingsAsync();
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
WorkstationAuditService = ScopedServices.GetRequiredService <IWorkstationAuditService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <WorkstationEvent, WorkstationEventFilter> >();
await BreadcrumbsService.SetAuditWorkstationEvents();
await DataTableService.InitializeAsync(WorkstationAuditService.GetWorkstationEventsAsync, WorkstationAuditService.GetWorkstationEventsCountAsync, StateHasChanged, nameof(WorkstationEvent.Date), ListSortDirection.Descending);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
LicenseService = ScopedServices.GetRequiredService <ILicenseService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <LicenseOrder, LicenseOrderFilter> >();
SynchronizationService.UpdateLicensesPage += UpdateLicensesPage;
await BreadcrumbsService.SetLicenseOrders();
await DataTableService.InitializeAsync(LicenseService.GetLicenseOrdersAsync, LicenseService.GetLicenseOrdersCountAsync, StateHasChanged, nameof(LicenseOrder.CreatedAt), ListSortDirection.Descending);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
GroupService = ScopedServices.GetRequiredService <IGroupService>();
//MainTableService = ScopedServices.GetRequiredService<IMainTableService<Group, GroupFilter>>();
//SynchronizationService.UpdateGroupsPage += UpdateGroupsPage;
await BreadcrumbsService.SetGroups();
//await MainTableService.InitializeAsync(GroupService.GetGroupsAsync, GroupService.GetGroupsCountAsync, ModalDialogService, StateHasChanged, nameof(Group.Name));
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
//SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
EmployeeService = ScopedServices.GetRequiredService <IEmployeeService>();
MainTableService = ScopedServices.GetRequiredService <IMainTableService <Employee, EmployeeFilter> >();
SynchronizationService.UpdateEmployeePage += UpdateEmployeePage;
await BreadcrumbsService.SetEmployees();
await MainTableService.InitializeAsync(EmployeeService.GetEmployeesAsync, EmployeeService.GetEmployeesCountAsync, ModalDialogService, StateHasChanged, nameof(Employee.FullName));
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
SharedAccountService = ScopedServices.GetRequiredService <ISharedAccountService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <SharedAccount, SharedAccountsFilter> >();
SynchronizationService.UpdateSharedAccountsPage += UpdateSharedAccountsPage;
await BreadcrumbsService.SetSharedAccounts();
await DataTableService.InitializeAsync(SharedAccountService.GetSharedAccountsAsync, SharedAccountService.GetSharedAccountsCountAsync, StateHasChanged, nameof(SharedAccount.Name), ListSortDirection.Ascending);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <HardwareVaultProfile, HardwareVaultProfileFilter> >();
SynchronizationService.UpdateHardwareVaultProfilesPage += UpdateHardwareVaultProfilesPage;
await DataTableService.InitializeAsync(HardwareVaultService.GetHardwareVaultProfilesAsync, HardwareVaultService.GetHardwareVaultProfileCountAsync, StateHasChanged, nameof(HardwareVaultProfile.Name), ListSortDirection.Ascending);
await BreadcrumbsService.SetHardwareVaultProfiles();
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
TemplateService = ScopedServices.GetRequiredService <ITemplateService>();
MainTableService = ScopedServices.GetRequiredService <IMainTableService <Template, TemplateFilter> >();
SynchronizationService.UpdateTemplatesPage += UpdateTemplatesPage;
await BreadcrumbsService.SetTemplates();
await MainTableService.InitializeAsync(TemplateService.GetTemplatesAsync, TemplateService.GetTemplatesCountAsync, ModalDialogService, StateHasChanged, nameof(Template.Name), ListSortDirection.Ascending);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
WorkstationService = ScopedServices.GetRequiredService <IWorkstationService>();
DataTableService = ScopedServices.GetRequiredService <IDataTableService <WorkstationProximityVault, WorkstationDetailsFilter> >();
SynchronizationService.UpdateWorkstationDetailsPage += UpdateWorkstationDetailsPage;
await LoadWorkstationAsync();
await BreadcrumbsService.SetWorkstationDetails(Workstation.Name);
await DataTableService.InitializeAsync(WorkstationService.GetProximityVaultsAsync, WorkstationService.GetProximityVaultsCountAsync, StateHasChanged, nameof(WorkstationProximityVault.HardwareVaultId), entityId : WorkstationId);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
WorkstationService = ScopedServices.GetRequiredService <IWorkstationService>();
AppSettingsService = ScopedServices.GetRequiredService <IAppSettingsService>();
SynchronizationService.UpdateAlarmPage += UpdateAlarmPage;
await BreadcrumbsService.SetAlarm();
await GetAlarmStateAsync();
WorkstationOnline = RemoteWorkstationConnectionsService.WorkstationsOnlineCount();
WorkstationCount = await WorkstationService.GetWorkstationsCountAsync(new DataLoadingOptions <WorkstationFilter>());
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
try
{
GroupService = ScopedServices.GetRequiredService <IGroupService>();
MainTableService = ScopedServices.GetRequiredService <IMainTableService <GroupMembership, GroupMembershipFilter> >();
SynchronizationService.UpdateGroupDetailsPage += UpdateGroupDetailsPage;
await LoadGroupAsync();
await BreadcrumbsService.SetGroupDetails(Group.Name);
await MainTableService.InitializeAsync(GroupService.GetGruopMembersAsync, GroupService.GetGruopMembersCountAsync, ModalDialogService, StateHasChanged, nameof(GroupMembership.Employee.FullName), entityId : GroupId);
SetInitialized();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
SetLoadFailed(ex.Message);
}
}
protected override async Task OnInitializedAsync()
{
SetGeneralTab();
await BreadcrumbsService.SetProfile();
}
protected override async Task OnInitializedAsync()
{
await BreadcrumbsService.SetAuditSummaries();
GetByDaysAndEmployeesTab();
}
