Esempio n. 1
0
        public async Task <IActionResult> OnGetAsync(string userId, string email, string code)
        {
            if (userId == null || email == null || code == null)
            {
                return(RedirectToPage("/Index"));
            }

            var user = await _userService.FindByIdAsync(userId);

            if (user == null)
            {
                return(NotFound($"Gebruiker met ID '{userId}' niet gevonden."));
            }

            var result = await _userService.ChangeEmailAsync(user, email, code);

            if (!result.Succeeded)
            {
                StatusMessage = "Fout wijzigen van e-mail";
                return(Page());
            }

            await _signInService.RefreshSignInAsync(user);

            StatusMessage = "Bedankt om de wijziging van uw e-mail te bevestigen.";
            return(Page());
        }
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            var user = await _userService.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Unable to load user with ID '{_userService.GetUserId(User)}'."));
            }

            var changePasswordResult = await _userService.ChangePasswordAsync(user, Input.OldPassword, Input.NewPassword);

            if (!changePasswordResult.Succeeded)
            {
                foreach (var error in changePasswordResult.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
                return(Page());
            }

            await _signInService.RefreshSignInAsync(user);

            _logger.LogInformation("User changed their password successfully.");
            StatusMessage = "Uw wachtwoord is gewijzigd.";

            return(RedirectToPage());
        }
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            var user = await _userService.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Unable to load user with ID '{_userService.GetUserId(User)}'."));
            }

            var addPasswordResult = await _userService.AddPasswordAsync(user, Input.NewPassword);

            if (!addPasswordResult.Succeeded)
            {
                foreach (var error in addPasswordResult.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
                return(Page());
            }

            await _signInService.RefreshSignInAsync(user);

            StatusMessage = "Uw wachtwoord is geplaatst.";

            return(RedirectToPage());
        }
Esempio n. 4
0
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            var user = await userService.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Unable to load user with ID '{userService.GetUserId(User)}'."));
            }

            var email = await userService.GetEmailAsync(user);

            if (Input.Email != email)
            {
                var setEmailResult = await userService.SetEmailAsync(user, Input.Email);

                if (!setEmailResult.Succeeded)
                {
                    var userId = await userService.GetUserIdAsync(user);

                    throw new InvalidOperationException($"Unexpected error occurred setting email for user with ID '{userId}'.");
                }
            }

            if (Input.FirstName != user.FirstName)
            {
                user.FirstName = Input.FirstName;
            }

            if (Input.LastName != user.LastName)
            {
                user.LastName = Input.LastName;
            }

            var phoneNumber = await userService.GetPhoneNumberAsync(user);

            if (Input.PhoneNumber != phoneNumber)
            {
                var setPhoneResult = await userService.SetPhoneNumberAsync(user, Input.PhoneNumber);

                if (!setPhoneResult.Succeeded)
                {
                    var userId = await userService.GetUserIdAsync(user);

                    throw new InvalidOperationException($"Unexpected error occurred setting phone number for user with ID '{userId}'.");
                }
            }

            await userService.UpdateAsync(user);

            await signInService.RefreshSignInAsync(user);

            StatusMessage = "Your profile has been updated";
            return(RedirectToPage());
        }
Esempio n. 5
0
        public async Task <IActionResult> OnPostAsync()
        {
            var user = await _userService.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Het is niet gelukt om de gebruiker te laden met ID'{_userService.GetUserId(User)}'."));
            }

            if (!ModelState.IsValid)
            {
                await LoadAsync(user);

                return(Page());
            }

            var phoneNumber = await _userService.GetPhoneNumberAsync(user);

            if (Input.PhoneNumber != phoneNumber)
            {
                var setPhoneResult = await _userService.SetPhoneNumberAsync(user, Input.PhoneNumber);

                if (!setPhoneResult.Succeeded)
                {
                    StatusMessage = "Onverwachte fout bij het proberen opslaan van de telefoonnummer.";
                    return(RedirectToPage());
                }
            }

            if (Input.ProfileImage != null)
            {
                KerykeionDbResult uploadProfileImageResult = await _userService.AddProfileImage(user, Input.ProfileImage);

                if (!uploadProfileImageResult.Successfull)
                {
                    StatusMessage = "Onverwachte fout bij het proberen uploaden van de profielfoto.";
                    return(RedirectToPage());
                }
            }

            var language = await _userService.GetLanguageAsync(user);

            if (Input.Language != language)
            {
                KerykeionDbResult setLanguageResult = await _userService.SetLanguageAsync(user, Input.Language);

                if (!setLanguageResult.Successfull)
                {
                    StatusMessage = "Onverwachte fout bij het proberen wijwigen van de taal.";
                    return(RedirectToPage());
                }
            }

            await _signInService.RefreshSignInAsync(user);

            StatusMessage = "Uw profiel is geupdatet.";
            return(RedirectToPage());
        }
Esempio n. 6
0
        public async Task <IActionResult> OnPostAsync()
        {
            var user = await _userService.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Unable to load user with ID '{_userService.GetUserId(User)}'."));
            }

            await _userService.SetTwoFactorEnabledAsync(user, false);

            await _userService.ResetAuthenticatorKeyAsync(user);

            _logger.LogInformation("User with ID '{UserId}' has reset their authentication app key.", user.Id as string);

            await _signInService.RefreshSignInAsync(user);

            StatusMessage = "Uw authenticator app werd gereset, u zult moeten uw authenticator app configureren met de nieuwe sleutel.";

            return(RedirectToPage("./EnableAuthenticator"));
        }