Example #1
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Kunde inte ladda användaren med ID '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #2
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Nie można załadować użytkownika z ID '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #3
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (hasPassword)
            {
                return(RedirectToPage("./ChangePassword"));
            }

            return(Page());
        }
Example #4
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Ude af stand til at indlæse bruger med ID '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #6
0
        public async Task <IActionResult> OnGetAsync(string id)
        {
            var user = await _userManager.FindByIdAsync(id);

            if (user == null)
            {
                return(NotFound($"Unable to load user with ID '{_userManager.FindByIdAsync(id)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound(_identityLocalizer["USER_NOTFOUND", _userManager.GetUserId(User)]));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (hasPassword)
            {
                return(RedirectToPage("./ChangePassword"));
            }

            return(Page());
        }
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Não foi possível encontrar o usuário '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #9
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"No se pudo cargar el usuario con ID '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (hasPassword)
            {
                return(RedirectToPage("./ChangePassword"));
            }

            return(Page());
        }
        public async Task <IActionResult> ChangePasswordAsync(ChangePasswordViewModel vm)
        {
            if (!ModelState.IsValid)
            {
                return(View(nameof(ChangePassword), vm));
            }
            var user = await _userManager.FindByNameAsync(User.Identity.Name);

            if (user == null)
            {
                _logger.LogCritical(Constants.UnknownId + " of user");
                return(RedirectToAction(nameof(ErrorController.Error), "Error"));
            }

            if (!_userManager.HasPasswordAsync(user).Result)
            {
                ModelState.AddModelError(nameof(ChangePasswordViewModel.NewPassword), Constants.LoginByExternalProviderMessage);
                return(View(nameof(ChangePassword), vm));
            }

            var isCorrectOld = await _userManager.CheckPasswordAsync(user, vm.OldPassword);

            if (isCorrectOld)
            {
                var result = await _userManager.ChangePasswordAsync(user, vm.OldPassword, vm.NewPassword);

                if (result.Succeeded)
                {
                    TempData["SuccessMessage"] = Constants.GeneralSuccessMessage;
                    return(View(nameof(ChangePassword)));
                }

                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(nameof(ChangePasswordViewModel.NewPassword), error.Description);
                    _logger.LogError(error.Description);
                    return(View(nameof(ChangePassword), vm));
                }
            }

            ModelState.AddModelError(nameof(ChangePasswordViewModel.OldPassword),
                                     Constants.WrongOldPasswordMessage);
            return(View(nameof(ChangePassword), vm));
        }
        //public async Task<IActionResult> OnGetAsync()
        //{
        //    var user = await _userManager.GetUserAsync(User);
        //    if (user == null)
        //    {
        //        throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
        //    }

        //    var hasPassword = await _userManager.HasPasswordAsync(user);
        //    if (!hasPassword)
        //    {
        //        return RedirectToPage("./SetPassword");
        //    }
        //    ViewData["Id"] = user.Id;
        //    return Page();
        //}

        public async Task <IActionResult> OnGetAsync(string id)
        {
            if (id == null)
            {
                var user = await _userManager.GetUserAsync(User);

                if (user == null)
                {
                    throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
                }

                var hasPassword = await _userManager.HasPasswordAsync(user);

                if (!hasPassword)
                {
                    return(RedirectToPage("./SetPassword"));
                }
                ViewData["Id"] = user.Id;
                return(Page());
            }
            else
            {
                var user = await _userManager.GetUserAsync(User);

                if (user == null)
                {
                    throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
                }

                UserStore <VehicleUser> store = new UserStore <VehicleUser>(_dbContext);
                VehicleUser             cUser = await store.FindByIdAsync(id);

                if (cUser != null)
                {
                    if (cUser.TownId == user.TownId && User.IsInRole("TownManager") ||
                        User.IsInRole("Admins") || User.IsInRole("GlobalVisitor"))
                    {
                        ViewData["Id"] = id;
                        return(Page());
                    }
                }
            }
            return(NotFound());
        }
Example #12
0
        public async Task <IActionResult> OnGetAsync(string returnUrl = null)
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Usuario no encontrado ID: '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            ViewData["ReturnUrl"] = returnUrl;
            return(Page());
        }
Example #13
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                _logger.LogError("No existe usuario con sesión iniciada.");
                return(NotFound("No existe usuario con sesión iniciada."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #14
0
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                _logger.Warning("{user} - adatait nem lehetett betölteni- jelszó változtatás, OnGet", _userManager.GetUserId(User));
                return(NotFound($"Felhasználói adatokat nem tudtuk betölteni '{_userManager.GetUserId(User)}'."));
            }

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #15
0
        public async Task <IActionResult> Index(ManageMessageId?message = null)
        {
            ViewData["StatusMessage"] =
                message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
                : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
                : message == ManageMessageId.Error ? "An error has occurred."
                : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
                : "";

            var user = await GetCurrentUserAsync();

            var model = new IndexViewModel
            {
                HasPassword = await _userManager.HasPasswordAsync(user),
                Logins      = await _userManager.GetLoginsAsync(user),
            };

            return(View(model));
        }
Example #16
0
        public async Task <IActionResult> Index(ManageMessageId?message = null) //открытие профиля текущего пользователя
        {
            ViewData["StatusMessage"] =
                message == ManageMessageId.ChangePasswordSuccess ? "Пароль обновлён"
                : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
                : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set."
                : message == ManageMessageId.Error ? "Возникла ошибка"
                : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added."
                : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
                : message == ManageMessageId.UpdateUserSuccess? "Данные обновлены"
                : "";

            var user = await GetCurrentUserAsync();

            if (user == null)
            {
                return(View("Error"));
            }
            var model = new IndexViewModel
            {
                HasPassword       = await _userManager.HasPasswordAsync(user),
                PhoneNumber       = await _userManager.GetPhoneNumberAsync(user),
                TwoFactor         = await _userManager.GetTwoFactorEnabledAsync(user),
                Logins            = await _userManager.GetLoginsAsync(user),
                BrowserRemembered = await _signInManager.IsTwoFactorClientRememberedAsync(user),
                User = user
            };
            var   ratings = _context.Ratings.Where(p => p.Post.UserId == user.Id).Include(p => p.User); //здесь и далее высчитывается суммарный ретинг
            float sum     = 0;

            foreach (Rating item in ratings)
            {
                sum += item.rating * item.User.Weight;
            }
            var comratings = _context.CommRates.Where(p => p.Comment.UserId == user.Id).Include(p => p.User); //рейтинг комментариев учитывается, но оценивается вдвое меньше

            foreach (CommRate item in comratings)
            {
                sum += Convert.ToSingle(item.value * 0.5); //меня напрягают приведения типов, от них стоит избавиться. Олсо не запилить ли раздельные счета за комменты и за посты?
            }
            model.User.rating = sum;
            return(View(model));
        }
Example #17
0
        async public Task <IActionResult> Settings(string message, bool isOk)
        {
            var user = await _userEngine.CurrentUser(_userManager.GetUserId(User));

            var userLogins = await _userManager.GetLoginsAsync(user);

            var otherLogins = _signInManager.GetExternalAuthenticationSchemes().Where(auth => userLogins.All(ul => auth.AuthenticationScheme != ul.LoginProvider)).ToList();

            ViewData["ShowRemoveButton"] = user.PasswordHash != null || userLogins.Count > 1;

            return(View(new SettingsViewModel
            {
                User = user,
                HasPassword = await _userManager.HasPasswordAsync(user),
                CurrentLogins = userLogins,
                OtherLogins = otherLogins,
                SmsNotAllowed = user.SmsNotAllowed.HasValue && user.SmsNotAllowed.Value
            }));
        }
Example #18
0
        public async Task <IActionResult> OnGetAsync(string userId)
        {
            if (User.Identity.Name != null)
            {
                var user2 = await _userManager.FindByEmailAsync(User.Identity.Name);

                var administrador = user2.Administrador;

                if (administrador == true)
                {
                    TempData["hablitarUser"] = "******";
                }
            }

            if (userId != null)
            {
                TempData["userId"] = userId;
            }

            //TempData["habilitarCitas"] = "1";

            var user = await _userManager.GetUserAsync(User);

            if (TempData["userId"] != null)
            {
                user = await _userManager.FindByIdAsync(TempData["userId"].ToString());
            }

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            TempData["userId"] = user.Id;
            return(Page());
        }
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'ChangePasswordModel.OnGetAsync()'
        public async Task <IActionResult> OnGetAsync()
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'ChangePasswordModel.OnGetAsync()'
        {
            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #20
0
 public static async Task<IndexViewModel> ToViewModel(this ApplicationUser user, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
 {
     var result = new IndexViewModel
     {
         HasPassword = await userManager.HasPasswordAsync(user),
         EmailAddress = user.Email,
         IsEmailAddressConfirmed = user.EmailConfirmed,
         IsPhoneNumberConfirmed = user.PhoneNumberConfirmed,
         PhoneNumber = await userManager.GetPhoneNumberAsync(user),
         TwoFactor = await userManager.GetTwoFactorEnabledAsync(user),
         Logins = await userManager.GetLoginsAsync(user),
         BrowserRemembered = await signInManager.IsTwoFactorClientRememberedAsync(user),
         AssociatedSkills = user.AssociatedSkills,
         TimeZoneId = user.TimeZoneId,
         Name = user.Name,
         ProposedNewEmailAddress = user.PendingNewEmail
     };
     return result;
 }
Example #21
0
        public async Task <IActionResult> OnGetAsync()
        {
            ProductIndex = _productVMService.GetProductsVM(HttpContext, null);
            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (hasPassword)
            {
                return(RedirectToPage("./ChangePassword"));
            }

            return(Page());
        }
        public async Task <ExternalLoginsViewModel> GetExternalLoginsViewModelAsync(string statusMessage)
        {
            var user = await this.GetApplicationUserAsync();

            var currentLogins = await UserManager.GetLoginsAsync(user);

            var authenticationSchemes = await SignInManager.GetExternalAuthenticationSchemesAsync();

            var otherLogins = authenticationSchemes.Where(auth => currentLogins.All(ul => auth.Name != ul.LoginProvider)).ToList();

            var showRemoveButton = await UserManager.HasPasswordAsync(user) || currentLogins.Count > 1;

            return(new ExternalLoginsViewModel
            {
                CurrentLogins = currentLogins,
                OtherLogins = otherLogins,
                ShowRemoveButton = showRemoveButton,
                StatusMessage = statusMessage
            });
        }
Example #23
0
        public async Task <IActionResult> OnGetAsync()
        {
            ViewData["totalItems"] = HttpContext.Session.GetInt32("totalItems") != null?HttpContext.Session.GetInt32("totalItems") : 0;

            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
        public async Task <IActionResult> OnGetAsync()
        {
            ViewData["SettingsName"] = "Password";

            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }

            return(Page());
        }
Example #25
0
        /// <summary>
        /// Asynchronous method that represents the HTTP GET method, where
        /// it is used to request data from a specific resource. In this case, the
        /// form for changing the password.
        /// If the user in question is not authenticated, a page Not Found (404)
        /// is obtained.
        /// If the user does not have a password, he is redirected to the password
        /// set page.
        /// </summary>
        /// <returns>Returns a Task of an IActionResult</returns>
        /// <seealso cref="Task"/>
        /// <seealso cref="IActionResult"/>
        public async Task <IActionResult> OnGetAsync()
        {
            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }
            //ViewBag for bell icon on the nav menu
            ViewData["HasNotificationToRead"] = _context.Notification.Include(n => n.User).Where(notif => notif.DestinaryID == user.Id && !notif.IsRead).Count();

            return(Page());
        }
Example #26
0
        private async Task <ProfileVM> GetProfileVM <T>(UserWithClaims?user, T?model = null, string?errorMessage = null, string?successMessage = null) where T : class
        {
            if (user == null)
            {
                throw new DomainException("Cannot find user.");
            }

            var taskForProviders = signInManager.GetExternalProvidersAsync();
            var taskForPassword  = userManager.HasPasswordAsync(user.Identity);
            var taskForLogins    = userManager.GetLoginsAsync(user.Identity);

            await Task.WhenAll(taskForProviders, taskForPassword, taskForLogins);

            var result = new ProfileVM
            {
                Id                = user.Id,
                ClientSecret      = user.ClientSecret() !,
                Email             = user.Email,
                ErrorMessage      = errorMessage,
                ExternalLogins    = taskForLogins.Result,
                ExternalProviders = taskForProviders.Result,
                DisplayName       = user.DisplayName() !,
                HasPassword       = taskForPassword.Result,
                HasPasswordAuth   = identityOptions.AllowPasswordAuth,
                IsHidden          = user.IsHidden(),
                SuccessMessage    = successMessage
            };

            if (model != null)
            {
                SimpleMapper.Map(model, result);
            }

            if (result.Properties == null)
            {
                result.Properties = user.GetCustomProperties().Select(UserProperty.FromTuple).ToList();
            }

            return(result);
        }
    }
Example #27
0
        public async Task <IActionResult> ExternalLogins()
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(Unauthorized());
            }

            var model = new ExternalLoginsViewModel()
            {
                CurrentLogins = await _userManager.GetLoginsAsync(user)
            };

            model.OtherLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
                                .Where(auth => model.CurrentLogins.All(ul => auth.Name != ul.LoginProvider))
                                .ToList();
            model.ShowRemoveButton = await _userManager.HasPasswordAsync(user) || model.CurrentLogins.Count > 1;

            return(View(model));
        }
Example #28
0
        public async Task <IActionResult> Index(ManageMessageId?message = null)
        {
            ViewData["StatusMessage"] =
                message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
                : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
                : message == ManageMessageId.Error ? "An error has occurred."
                : "";

            var user = await GetCurrentUserAsync();

            var model = new IndexViewModel
            {
                HasPassword       = await _userManager.HasPasswordAsync(user),
                PhoneNumber       = await _userManager.GetPhoneNumberAsync(user),
                TwoFactor         = await _userManager.GetTwoFactorEnabledAsync(user),
                Logins            = await _userManager.GetLoginsAsync(user),
                BrowserRemembered = await _signInManager.IsTwoFactorClientRememberedAsync(user)
            };

            return(View(model));
        }
Example #29
0
        public async Task <IActionResult> ExternalLogins()
        {
            var user = await UserManager.GetUserAsync(User);

            if (user == null)
            {
                throw new ApplicationException($"Unable to load user with ID '{UserManager.GetUserId(User)}'.");
            }

            var model = new ExternalLoginsViewModel {
                CurrentLogins = await UserManager.GetLoginsAsync(user)
            };

            model.OtherLogins = (await SignInManager.GetExternalAuthenticationSchemesAsync())
                                .Where(auth => model.CurrentLogins.All(ul => auth.Name != ul.LoginProvider))
                                .ToList();
            model.ShowRemoveButton = await UserManager.HasPasswordAsync(user) || model.CurrentLogins.Count > 1;

            model.StatusMessage = StatusMessage;

            return(View(model));
        }
Example #30
0
        public async Task <IActionResult> SetPassword()
        {
            var user = await UserManager.GetUserAsync(User);

            if (user == null)
            {
                throw new ApplicationException($"Unable to load user with ID '{UserManager.GetUserId(User)}'.");
            }

            var hasPassword = await UserManager.HasPasswordAsync(user);

            if (hasPassword)
            {
                return(RedirectToAction(nameof(ChangePassword)));
            }

            var model = new SetPasswordViewModel {
                StatusMessage = StatusMessage
            };

            return(View(model));
        }
        public async Task <IActionResult> ChangePassword()
        {
            var user = await _userManager.GetUserAsync(User);

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

            var hasPassword = await _userManager.HasPasswordAsync(user);

            if (!hasPassword)
            {
                return(RedirectToPage("./SetPassword"));
            }
            var vm = new ChangePasswordViewModel()
            {
                StatusMessage = ""
            };

            return(View(vm));
        }
 public static async Task<IndexViewModel> ToViewModel(this ApplicationUser user, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
 {
     var profileCompletenessWarnings = user.ValidateProfileCompleteness();
     var result = new IndexViewModel
     {
         HasPassword = await userManager.HasPasswordAsync(user),
         EmailAddress = user.Email,
         IsEmailAddressConfirmed = user.EmailConfirmed,
         IsPhoneNumberConfirmed = user.PhoneNumberConfirmed,
         PhoneNumber = await userManager.GetPhoneNumberAsync(user),
         TwoFactor = await userManager.GetTwoFactorEnabledAsync(user),
         Logins = await userManager.GetLoginsAsync(user),
         BrowserRemembered = await signInManager.IsTwoFactorClientRememberedAsync(user),
         AssociatedSkills = user.AssociatedSkills,
         TimeZoneId = user.TimeZoneId,
         FirstName = user.FirstName,
         LastName = user.LastName,
         ProposedNewEmailAddress = user.PendingNewEmail,
         IsProfileComplete = user.IsProfileComplete(),
         ProfileCompletenessWarnings = profileCompletenessWarnings.Select(p => p.ErrorMessage)
     };
     return result;
 }
        public void PasswordHash()
        {
            using (UserStore<IdentityUser> store = new UserStore<IdentityUser>())
            {
                using (UserManager<IdentityUser> manager = new UserManager<IdentityUser>(store))
                {
                    var user = User;
                    string passwordPlain = Guid.NewGuid().ToString("N");
                    string passwordHash = manager.PasswordHasher.HashPassword(passwordPlain);

                    var taskUserSet = store.SetPasswordHashAsync(user, passwordHash);
                    taskUserSet.Wait();

                    var taskHasHash = manager.HasPasswordAsync(user.Id);
                    taskHasHash.Wait();
                    Assert.IsTrue(taskHasHash.Result, "PasswordHash not set");

                    var taskUser = store.GetPasswordHashAsync(user);
                    taskUser.Wait();
                    Assert.AreEqual<string>(passwordHash, taskUser.Result, "PasswordHash not equal");
                    user.PasswordHash = passwordHash;
                    try
                    {
                        var task = store.GetPasswordHashAsync(null);
                        task.Wait();
                    }
                    catch (Exception ex)
                    {
                        Assert.IsNotNull(ex, "Argument exception not raised");
                    }

                    try
                    {
                        var task = store.HasPasswordAsync(null);
                        task.Wait();
                    }
                    catch (Exception ex)
                    {
                        Assert.IsNotNull(ex, "Argument exception not raised");
                    }

                    try
                    {
                        var task = store.SetPasswordHashAsync(null, passwordHash);
                        task.Wait();
                    }
                    catch (Exception ex)
                    {
                        Assert.IsNotNull(ex, "Argument exception not raised");
                    }

                    try
                    {
                        var task = store.SetPasswordHashAsync(user, null);
                        task.Wait();
                    }
                    catch (Exception ex)
                    {
                        Assert.IsNotNull(ex, "Argument exception not raised");
                    }
                }
            }
        }