Ejemplo n.º 1
0
        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();
            }
        }
Ejemplo n.º 2
0
        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();
            }
        }
Ejemplo n.º 3
0
        protected override async Task OnInitializedAsync()
        {
            try
            {
                HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();

                InputType = "Password";

                HardwareVault = await HardwareVaultService.GetVaultByIdAsync(HardwareVaultId);

                if (HardwareVault == null)
                {
                    throw new Exception("HardwareVault not found.");
                }

                Code = await HardwareVaultService.GetVaultActivationCodeAsync(HardwareVault.Id);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.Message);
                await ToastService.ShowToastAsync(ex.Message, ToastType.Error);

                await ModalDialogService.CancelAsync();
            }
        }
Ejemplo n.º 4
0
        protected override async Task OnInitializedAsync()
        {
            try
            {
                HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();

                ModalDialogService.OnCancel += OnCancelAsync;

                AccessProfile = await HardwareVaultService.GetProfileByIdAsync(HardwareVaultProfileId);

                if (AccessProfile == null)
                {
                    throw new Exception("Hardware Vault Profile not found.");
                }

                InitPinExpirationValue = AccessProfile.PinExpirationConverted;
                InitPinLengthValue     = AccessProfile.PinLength;
                InitPinTryCountValue   = AccessProfile.PinTryCount;

                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();
            }
        }
Ejemplo n.º 5
0
        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();
            }
        }
Ejemplo n.º 6
0
        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();
            }
        }
Ejemplo n.º 7
0
        private async Task LoadDataAsync()
        {
            var filter = new HardwareVaultFilter()
            {
                Status = VaultStatus.Ready
            };

            TotalRecords = await HardwareVaultService.GetVaultsCountAsync(new DataLoadingOptions <HardwareVaultFilter>
            {
                SearchText = SearchText,
                Filter     = filter
            });

            HardwareVaults = await HardwareVaultService.GetVaultsAsync(new DataLoadingOptions <HardwareVaultFilter>
            {
                Take          = TotalRecords,
                SortedColumn  = nameof(HardwareVault.Id),
                SortDirection = ListSortDirection.Ascending,
                SearchText    = SearchText,
                Filter        = filter
            });

            SelectedHardwareVault = null;
            StateHasChanged();
        }
Ejemplo n.º 8
0
        protected override async Task OnInitializedAsync()
        {
            try
            {
                LicenseService       = ScopedServices.GetRequiredService <ILicenseService>();
                HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();

                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);
                }

                if (!LicenseOrder.ProlongExistingLicenses)
                {
                    _newLicenseOrder = new NewLicenseOrder()
                    {
                        ContactEmail   = LicenseOrder.ContactEmail,
                        Note           = LicenseOrder.Note,
                        StartDate      = LicenseOrder.StartDate.Value,
                        EndDate        = LicenseOrder.EndDate,
                        HardwareVaults = await HardwareVaultService.GetVaultsWithoutLicenseAsync()
                    };
                    _newLicenseOrder.HardwareVaults.ForEach(x => x.Checked = LicenseOrder.HardwareVaultLicenses.Any(d => d.HardwareVaultId == x.Id));
                }
                else
                {
                    _renewLicenseOrder = new RenewLicenseOrder()
                    {
                        ContactEmail   = LicenseOrder.ContactEmail,
                        Note           = LicenseOrder.Note,
                        EndDate        = LicenseOrder.EndDate,
                        HardwareVaults = await HardwareVaultService.GetVaultsWithLicenseAsync()
                    };
                    _renewLicenseOrder.HardwareVaults.ForEach(x => x.Checked = LicenseOrder.HardwareVaultLicenses.Any(d => d.HardwareVaultId == x.Id));
                }

                SetInitialized();
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.Message);
                await ToastService.ShowToastAsync(ex.Message, ToastType.Error);

                await ModalDialogService.CancelAsync();
            }
        }
Ejemplo n.º 9
0
        protected override async Task OnInitializedAsync()
        {
            HardwareVaultService = ScopedServices.GetRequiredService <IHardwareVaultService>();

            AccessProfile = await HardwareVaultService.ProfileQuery().AsNoTracking().FirstOrDefaultAsync(x => x.Id == "default");

            AccessProfile.Id   = null;
            AccessProfile.Name = null;

            InitPinExpirationValue = AccessProfile.PinExpirationConverted;
            InitPinLengthValue     = AccessProfile.PinLength;
            InitPinTryCountValue   = AccessProfile.PinTryCount;
        }
Ejemplo n.º 10
0
        private async Task ImportVaultsAsync()
        {
            try
            {
                await HardwareVaultService.ImportVaultsAsync();

                await DataTableService.LoadTableDataAsync();

                await ToastService.ShowToastAsync("Vaults imported.", ToastType.Success);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.Message);
                await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
            }
        }
Ejemplo n.º 11
0
        private async Task DeleteProfileAsync()
        {
            try
            {
                await HardwareVaultService.DeleteProfileAsync(AccessProfile.Id);

                await ToastService.ShowToastAsync("Hardware vault profile deleted.", ToastType.Success);
                await ModalDialogClose();
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.Message, ex);
                await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
                await ModalDialogCancel();
            }
        }
Ejemplo n.º 12
0
        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();
            }
        }
Ejemplo n.º 13
0
        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();
            }
        }
Ejemplo n.º 14
0
 private async Task EditAsync()
 {
     try
     {
         await ButtonSpinner.SpinAsync(async() =>
         {
             await HardwareVaultService.UpdateRfidAsync(HardwareVault);
             await ToastService.ShowToastAsync("RFID updated.", ToastType.Success);
             await ModalDialogClose();
         });
     }
     catch (Exception ex)
     {
         Logger.LogError(ex.Message);
         await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
         await ModalDialogCancel();
     }
 }
Ejemplo n.º 15
0
 private async Task CreateProfileAsync()
 {
     try
     {
         await Button.SpinAsync(async() =>
         {
             await HardwareVaultService.CreateProfileAsync(AccessProfile);
             await ToastService.ShowToastAsync("Hardware vault profile created.", ToastType.Success);
             await ModalDialogClose();
         });
     }
     catch (Exception ex)
     {
         Logger.LogError(ex.Message);
         await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
         await ModalDialogCancel();
     }
 }
Ejemplo n.º 16
0
        private async Task CreateProfileAsync()
        {
            try
            {
                await ButtonSpinner.SpinAsync(async() =>
                {
                    await HardwareVaultService.CreateProfileAsync(AccessProfile);
                    await ToastService.ShowToastAsync("Hardware vault profile created.", ToastType.Success);
                    await SynchronizationService.UpdateHardwareVaultProfiles(ExceptPageId);
                    await ModalDialogService.CloseAsync();
                });
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.Message);
                await ToastService.ShowToastAsync(ex.Message, ToastType.Error);

                await ModalDialogService.CancelAsync();
            }
        }
Ejemplo n.º 17
0
        private async Task LoadDataAsync()
        {
            var filter = new HardwareVaultFilter()
            {
                Status = VaultStatus.Active
            };

            TotalRecords = await HardwareVaultService.GetVaultsCountAsync(new DataLoadingOptions <HardwareVaultFilter>
            {
                SearchText = SearchText,
                Filter     = filter
            });

            HardwareVaults = await HardwareVaultService.GetVaultsAsync(new DataLoadingOptions <HardwareVaultFilter>
            {
                Take          = TotalRecords,
                SortedColumn  = nameof(HardwareVault.Id),
                SortDirection = ListSortDirection.Ascending,
                SearchText    = SearchText,
                Filter        = filter
            });

            var count = await WorkstationService.GetProximityVaultsCountAsync(new DataLoadingOptions <WorkstationDetailsFilter>() { EntityId = WorkstationId });

            var proximityVaultFilter = new DataLoadingOptions <WorkstationDetailsFilter>()
            {
                Take          = count,
                SortedColumn  = nameof(WorkstationProximityVault.HardwareVaultId),
                SortDirection = ListSortDirection.Ascending,
                EntityId      = WorkstationId
            };
            var proximityVaults = await WorkstationService.GetProximityVaultsAsync(proximityVaultFilter);

            AlreadyAdded = proximityVaults.Count > 0;

            HardwareVaults        = HardwareVaults.Where(x => !proximityVaults.Select(s => s.HardwareVaultId).Contains(x.Id)).ToList();
            SelectedHardwareVault = null;
            StateHasChanged();
        }
Ejemplo n.º 18
0
        protected override async Task ModalDialogCancel()
        {
            await HardwareVaultService.UnchangedProfileAsync(AccessProfile);

            await base.ModalDialogCancel();
        }
Ejemplo n.º 19
0
        private async Task Next()
        {
            switch (WizardStep)
            {
            case WizardStep.Profile:
                var employeeNameExist = await EmployeeService.CheckEmployeeNameExistAsync(Employee);

                if (employeeNameExist)
                {
                    EmployeeValidationErrorMessage.DisplayError(nameof(Core.Entities.Employee.FirstName), $"{Employee.FirstName} {Employee.LastName} already exists.");
                    return;
                }
                var employeeIsValid = EmployeeContext.Validate();
                if (!employeeIsValid)
                {
                    return;
                }
                WizardStep = WizardStep.HardwareVault;
                break;

            case WizardStep.HardwareVault:
                if (SelectedHardwareVault == null)
                {
                    WarningMessage = "Please, select a vault.";
                    break;
                }
                WizardStep = WizardStep.WorkstationAccount;
                break;

            case WizardStep.WorkstationAccount:
                if (AccountType == AccountType.Personal)
                {
                    var accountIsValid = PersonalAccountContext.Validate();
                    if (!accountIsValid)
                    {
                        return;
                    }
                }
                WizardStep = WizardStep.Overview;
                break;

            case WizardStep.Overview:
                await CreateAsync();

                if (SelectedHardwareVault == null)
                {
                    await ToastService.ShowToastAsync("Employee created.", ToastType.Success);
                    await ModalDialogClose();

                    break;
                }
                Code = await HardwareVaultService.GetVaultActivationCodeAsync(SelectedHardwareVault.Id);

                Email      = Employee.Email;
                WizardStep = WizardStep.Activation;
                break;

            case WizardStep.Activation:
                await ToastService.ShowToastAsync("Employee created.", ToastType.Success);
                await ModalDialogClose();

                break;
            }
        }
Ejemplo n.º 20
0
 private async Task ModalDialogService_OnCancel()
 {
     await HardwareVaultService.UnchangedVaultAsync(HardwareVault);
 }
Ejemplo n.º 21
0
 private async Task OnCancelAsync()
 {
     await HardwareVaultService.UnchangedProfileAsync(AccessProfile);
 }
Ejemplo n.º 22
0
        protected override async Task ModalDialogCancel()
        {
            await HardwareVaultService.UnchangedVaultAsync(HardwareVault);

            await base.ModalDialogCancel();
        }