예제 #1
0
        public async Task <IHttpActionResult> AddUserToRole([FromBody] AddUserToRoleBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var role = await _roleManager.FindByNameAsync(model.RoleName);

            if (role == null)
            {
                return(NotFound());
            }
            var user = await _userManager.FindByNameAsync(model.Username);

            if (user == null)
            {
                return(NotFound());
            }
            var result = await _userManager.AddToRoleAsync(user.Id, role.Name);

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }
            return(Ok());
        }
        public OldHouseUser GetTestFackUser(string nickName, string userName, string password)
        {
            var user = MyUserManager.FindByNameAsync(userName).Result;

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

            user = new OldHouseUser {
                NickName     = nickName,
                UserName     = userName,
                PasswordHash = password
            };
            //todo put all oldhouse user roles in consts
            //todo use a fake user iu data base later
            user.Roles.Add("User");
            //it has no profile yet
            //todo may return a fake profile in data base
            var profile = CreateAFakeProfile();

            user.Profiles.Add(OldHouseUserProfile.PROFILENBAME, profile.Id);
            MyUserManager.CreateAsync(user).Wait();
            ProfileService.SaveOne(profile);
            return(user);
        }
예제 #3
0
        public async Task <TokenAuthorizeModel> RegisterExternalAsync(MyUserManager userManager, RegisterExternalViewModel viewModel)
        {
            var identity           = viewModel.ToEntity();
            var authenticationType = Enum.Parse <ExternalAuthenticationType>(viewModel.Provider, true);

            _externalAuthenticationFactory.Create(authenticationType).GetUserDetails(identity, viewModel.ProviderIdToken);

            identity.UserName = identity.Email;

            //If user exist in the system
            var user = await userManager.FindByNameAsync(identity.UserName);

            if (user != null)
            {
                return(await user.AuthorizeAsync(userManager, _extensionSettings.appSettings));
            }

            //if user is not exist in the system
            IdentityResult result = await userManager.CreateAsync(identity);

            if (result.Succeeded)
            {
                await updateOtherInfoForIdentity(userManager, identity);

                return(await identity.AuthorizeAsync(userManager, _extensionSettings.appSettings));
            }

            throw new FoodCourtException(ErrorMessage.USER_CREATE_FAIL);
        }
        public async Task <string> Login([FromBody] LoginRequest request)
        {
            var user = await _userManager.FindByNameAsync(request.UserName);

            var loginResult = await _userManager.CheckPasswordAsync(user, request.Password);

            return(loginResult ? "登录成功" : "用户名或密码错误");
        }
예제 #5
0
        public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByNameAsync(model.Email);

                if (user == null || !(await UserManager.IsEmailConfirmedAsync(user.Id)))
                {
                    // Don't reveal that the user does not exist or is not confirmed
                    return(View("ForgotPasswordConfirmation"));
                }

                // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                // Send an email with this link
                // string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
                // var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                // await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=\"" + callbackUrl + "\">here</a>");
                // return RedirectToAction("ForgotPasswordConfirmation", "Account");
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
예제 #6
0
        public async Task <TokenAuthorizeModel> AuthorizeAsync(MyUserManager userManager, LoginViewModel viewModel)
        {
            MyIdentity identity = viewModel.ToEntity();
            var        user     = await userManager.FindByNameAsync(identity.UserName);

            if (user == null)
            {
                throw new FoodCourtException(ErrorMessage.USER_IS_NOT_EXIST);
            }

            bool result = await userManager.CheckPasswordAsync(user, viewModel.Password);

            if (result)
            {
                return(await user.AuthorizeAsync(userManager, _extensionSettings.appSettings));
            }
            throw new FoodCourtException(ErrorMessage.PASSWORD_NOT_VALID);
        }
예제 #7
0
        public async Task <ActionResult> ResetPassword(ResetPasswordInputModel model)
        {
            //model.OldPassword = "";
#if DEBUG
            Debug.WriteLine("UserName="******"Password="******"ConfirmPassword="******"OldPassword="******"Id=" + model.Id.ToString());
#endif
            if (ModelState.IsValid)
            {
#if DEBUG
                Debug.WriteLine("Model is valid");
#endif
                var user = await _userManager.FindByNameAsync(model.UserName);

                if (user != null)
                {
#if DEBUG
                    Debug.WriteLine("user is not null");
#endif

                    /*
                     * var checkOldPassword =await _userManager.CheckPasswordAsync(user, model.OldPassword);
                     *
                     * if (checkOldPassword)
                     * { */
                    var result = await _userManager.RemovePasswordAsync(user.UserID);

                    if (result.Succeeded)
                    {
#if DEBUG
                        Debug.WriteLine("Password is removed to succeeded");
#endif
                        var result2 = await _userManager.AddPasswordAsync(user.UserID, model.Password);

                        if (result2.Succeeded)
                        {
#if DEBUG
                            Debug.WriteLine("Password is added to succeeded");
#endif
                            var result3 = await _userManager.SetSigninEndDateAsync(user);

#if DEBUG
                            if (result3)
                            {
                                Debug.WriteLine("SetSigninEndDateAsync is  well done");
                            }
#endif
                            var result4 = await _userManager.ResetAccessFailedCountAsync(user.UserID);

#if DEBUG
                            if (result4.Succeeded)
                            {
                                Debug.WriteLine("ResetAccessFailedCountAsync is executed.");
                            }
#endif

                            /*
                             * result4 = await _userManager.SetChangePasswordEndDateAsync(user);
                             #if DEBUG
                             * if (result4.Succeeded)
                             * {
                             *  Debug.WriteLine("SetChangePasswordEndDateAsync is executed.");
                             * }
                             #endif
                             *
                             * result4 = await _userManager.SetPasswordEnabledAsync(user, false);
                             #if DEBUG
                             * if (result4.Succeeded)
                             * {
                             *  Debug.WriteLine("SetPasswordEnabledAsync is executed.");
                             * }
                             #endif
                             */
                            return(RedirectToAction("List"));
                        }
                    }

                    //      }

                    /*      else
                     *    {
                     *        // Активизирована ли функция  блокировки учётки в системе
                     *        if (_userManager.LockoutEnabled)
                     *        {
                     *
                     #if DEBUG
                     *            Debug.WriteLine("++++ GetLockoutEnabledAsync is enabled");
                     #endif
                     *            // Увелечение счётчика неудачных попыток ввода пароля
                     *            if (await _userManager.AccessFailedAsync(user.UserID) == IdentityResult.Success)
                     *            {
                     #if DEBUG
                     *                Debug.WriteLine("~~~ AccessFailedAsync is working!");
                     #endif
                     *                if (await _userManager.IsLockedOutAsync(user.UserID))
                     *                {
                     #if DEBUG
                     *                    Debug.WriteLine("Account is locked out!");
                     #endif
                     *                    //Заблокировать учётку
                     *                    return View("Lockout");
                     *                }
                     *
                     *
                     *            }
                     *
                     *
                     *        }
                     *
                     *    } */
                }
            }
#if DEBUG
            Debug.WriteLine("Error is occured in ResetPassword");
#endif
            return(View(model));
        }
예제 #8
0
        /// <summary>
        /// Comprueba el inicio de sesión de un usuario y devuelve un estado que indica si ha sido exitoso o no. De no serlo, la respuesta indica la razón.
        /// </summary>
        /// <param name="username">Nombre de usuario.</param>
        /// <param name="password">Contraseña.</param>
        /// <param name="skipEmailConfirmed">¿Debe validarse que el email haya sido confirmado?</param>
        /// <returns></returns>
        public async Task <LogInResult> CheckCredentialsAsync(string username, string password, bool skipEmailConfirmed = false)
        {
            LogInResult result = new LogInResult(LoginStatusTypes.UnknownError);

            try
            {
                var user = await uM.FindByNameAsync(username);

                result = new LogInResult(LoginStatusTypes.UnknownError, user);
                if (user == null)
                {
                    //No existe
                    result.Status = LoginStatusTypes.DoesNotExist;
                    return(result);
                }

                if (user.LockoutEnabled)
                {
                    bool haltAndReturn = true;
                    //Usuario bloqueado
                    if (user.LockoutEnd.HasValue)
                    {
                        //El bloqueo es temporal.
                        if (user.LockoutEnd.Value <= DateTimeOffset.Now)
                        {
                            //El bloqueo ha expirado: desbloquear & continuar.
                            await uM.SetLockoutEnabledAsync(user, false);

                            haltAndReturn = false;
                        }
                        else
                        {
                            ///El bloqueo sigue activo.
                            result.Status = LoginStatusTypes.UserLocked_Temporal;
                        }
                    }
                    else
                    {
                        //El bloqueo es permanente
                        result.Status = LoginStatusTypes.UserLocked_Permanent;
                    }
                    if (haltAndReturn)
                    {
                        return(result);
                    }
                }

                if (!skipEmailConfirmed)
                {
                    if (!user.EmailConfirmed)
                    {
                        result.Status = LoginStatusTypes.EmailNotConfirmed;
                    }
                    return(result);
                }

                bool isPasswordValid = await uM.CheckPasswordAsync(user, password);

                if (!isPasswordValid)
                {
                    result.Status = LoginStatusTypes.PasswordNotValid;
                    return(result);
                }
                else
                {
                    result.Status = LoginStatusTypes.Success;
                }
            }
            catch (Exception)
            {
            }

            return(result);
        }