コード例 #1
0
ファイル: LoginsTest.cs プロジェクト: tomi85/aspnetidentity
 public async Task LinkUnlinkDeletesTest()
 {
     var db = UnitTestHelper.CreateDefaultDb();
     var mgr = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
     var user = new IdentityUser("linkunlinktest");
     UnitTestHelper.IsSuccess(await mgr.CreateAsync(user));
     var userLogin1 = new UserLoginInfo("provider1", "p1-1");
     var userLogin2 = new UserLoginInfo("provider2", "p2-1");
     Assert.Equal(0, (await mgr.GetLoginsAsync(user.Id)).Count);
     UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin1));
     Assert.Equal(1, user.Logins.Count(l => l.ProviderKey == "p1-1"));
     Assert.Equal(1, (await mgr.GetLoginsAsync(user.Id)).Count);
     UnitTestHelper.IsSuccess(await mgr.AddLoginAsync(user.Id, userLogin2));
     Assert.Equal(1, user.Logins.Count(l => l.ProviderKey == "p2-1"));
     Assert.Equal(2, (await mgr.GetLoginsAsync(user.Id)).Count);
     UnitTestHelper.IsSuccess(await mgr.RemoveLoginAsync(user.Id, userLogin1));
     Assert.Equal(0, user.Logins.Count(l => l.ProviderKey == "p1-1"));
     Assert.Equal(1, user.Logins.Count(l => l.ProviderKey == "p2-1"));
     Assert.Equal(1, (await mgr.GetLoginsAsync(user.Id)).Count());
     UnitTestHelper.IsSuccess(await mgr.RemoveLoginAsync(user.Id, userLogin2));
     Assert.Equal(0, (await mgr.GetLoginsAsync(user.Id)).Count);
     Assert.Equal(0, db.Set<IdentityUserLogin>().Count());
 }
コード例 #2
0
        public async Task <IActionResult> OnPostRemoveLoginAsync(string loginProvider, string providerKey)
        {
            var user = await _userManager.GetUserAsync(User);

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

            var result = await _userManager.RemoveLoginAsync(user, loginProvider, providerKey);

            if (!result.Succeeded)
            {
                StatusMessage = "The external login was not removed.";
                return(RedirectToPage());
            }

            await _signInManager.RefreshSignInAsync(user);

            StatusMessage = "The external login was removed.";
            ShowSuccess   = false;
            return(RedirectToPage());
        }
コード例 #3
0
        public async Task <IActionResult> OnPostRemoveLoginAsync(string loginProvider, string providerKey)
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"Şu kullanıcıya erişilemiyor: '{_userManager.GetUserId(User)}'."));
            }

            var result = await _userManager.RemoveLoginAsync(user, loginProvider, providerKey);

            if (!result.Succeeded)
            {
                var userId = await _userManager.GetUserIdAsync(user);

                throw new InvalidOperationException($"Şu kullanıcı için dış giriş kaldırılırken bilinmeyen bir hata oluştu: '{userId}'.");
            }

            await _signInManager.RefreshSignInAsync(user);

            StatusMessage = "The external login was removed.";
            return(RedirectToPage());
        }
コード例 #4
0
        public async Task <IActionResult> OnPostRemoveLoginAsync(string loginProvider, string providerKey)
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                return(NotFound($"کاربر با شناسه '{_userManager.GetUserId(User)}' یافت نشد."));
            }

            var result = await _userManager.RemoveLoginAsync(user, loginProvider, providerKey);

            if (!result.Succeeded)
            {
                var userId = await _userManager.GetUserIdAsync(user);

                throw new InvalidOperationException($"خطای غیر منتظره در هنگام حذف ورود خارجی کاربر با شناسه '{userId}'.");
            }

            await _signInManager.RefreshSignInAsync(user);

            StatusMessage = "ورود خارجی حذف گردید.";
            return(RedirectToPage());
        }
コード例 #5
0
        public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
        {
            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                _logger.LogError("Unable to load user with ID '{UserId}'.", _userManager.GetUserId(User));
                return(RedirectToAction(nameof(Login)));
            }

            var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);

            if (!result.Succeeded)
            {
                _logger.LogError("Unexpected error occurred adding external login info for user '{UserName}'.", user.UserName);
                return(RedirectToAction(nameof(Login)));
            }

            await _signInManager.SignInAsync(user, isPersistent : false);

            //StatusMessage = "The external login was removed.";
            return(RedirectToAction(nameof(ExternalLogins)));
        }
コード例 #6
0
        public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
        {
            ViewData["AlleCategorien"] = _categorieRepository.GetAll().ToList();

            var user = await _userManager.GetUserAsync(User);

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

            var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);

            if (!result.Succeeded)
            {
                throw new ApplicationException($"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
            }

            await _signInManager.SignInAsync(user, isPersistent : false);

            StatusMessage = "De externe login werd succesvol verwijderd.";
            return(RedirectToAction(nameof(ExternalLogins)));
        }
コード例 #7
0
        public async Task <IActionResult> OnPostRemoveLoginAsync(string loginProvider, string providerKey)
        {
            var user = await _userManager.GetUserAsync(User);

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

            var result = await _userManager.RemoveLoginAsync(user, loginProvider, providerKey);

            if (!result.Succeeded)
            {
                var userId = await _userManager.GetUserIdAsync(user);

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

            await _signInManager.RefreshSignInAsync(user);

            StatusMessage = "The external login was removed.";
            return(RedirectToPage());
        }
コード例 #8
0
        public async Task <IActionResult> OnPostRemoveLoginAsync(string loginProvider, string providerKey)
        {
            var user = await _userManager.GetUserAsync(User);

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

            var result = await _userManager.RemoveLoginAsync(user, loginProvider, providerKey);

            if (!result.Succeeded)
            {
                var userId = await _userManager.GetUserIdAsync(user);

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

            await _signInManager.RefreshSignInAsync(user);

            TempData.Success(_loc.Text(LocalizedBackendMessages.ExternalLoginsRemoveSuccess).Value);
            return(RedirectToPage());
        }
コード例 #9
0
        public async Task <ActionResult> DeleteUser(string userid)
        {
            if (AdmUsrRole == "Admin")
            {
                return(RedirectToAction("Index", "Admin", new
                {
                    Message =
                        ManageMessageId.HighRankedUser
                }));
            }
            userid = context.Users.Where(x => x.UserName == AdmUsrName).Select(x =>
                                                                               x.Id).FirstOrDefault();
            var user = await UserManager.FindByIdAsync(userid);

            var userClaims = await UserManager.GetClaimsAsync(user.Id);

            var userRoles = await UserManager.GetRolesAsync(user.Id);

            var userLogins = await UserManager.GetLoginsAsync(user.Id);

            foreach (var claim in userClaims)
            {
                await UserManager.RemoveClaimAsync(user.Id, claim);
            }
            string[] roles = new string[userRoles.Count];
            userRoles.CopyTo(roles, 0);
            await UserManager.RemoveFromRolesAsync(user.Id, roles);

            foreach (var log in userLogins)
            {
                await UserManager.RemoveLoginAsync(user.Id, new UserLoginInfo(log.LoginProvider, log.ProviderKey));
            }
            await UserManager.DeleteAsync(user);

            return(RedirectToAction("Index", "Admin", new { Message = ManageMessageId.UserDeleted }));
        }
コード例 #10
0
        public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel account)
        {
            var user = await GetCurrentUserAsync();

            if (user != null)
            {
                var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);

                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent : false);

                    TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
                        AlertType = SiteAlertTagHelper.AlertType.Success, MessageId = MessageId.RemoveLoginSuccess
                    });
                    return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _tenantContext.SiteContext.UrlSegmentValue })));
                }
            }

            TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
                AlertType = SiteAlertTagHelper.AlertType.Danger, MessageId = MessageId.RemoveLoginFailure
            });
            return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _tenantContext.SiteContext.UrlSegmentValue })));
        }
コード例 #11
0
        public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
        {
            ViewData["AllCategories"] = _categoryRepository.GetAll().ToList();

            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                throw new ApplicationException($"Không thể lấy thông tin người dùng '{_userManager.GetUserId(User)}'.");
            }

            var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);

            if (!result.Succeeded)
            {
                throw new ApplicationException(
                          $"Xảy ra lỗi không mong muốn khi xóa đăng nhập bên ngoài cho người dùng '{user.Id}'.");
            }

            await _signInManager.SignInAsync(user, isPersistent : false);

            StatusMessage = "Đăng nhập bên ngoài đã được xóa thành công.";
            return(RedirectToAction(nameof(ExternalLogins)));
        }
コード例 #12
0
        public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
        {
            var user = await _userManager.GetUserAsync(User);

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

            var result =
                await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);

            if (!result.Succeeded)
            {
                throw new ApplicationException(
                          $"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
            }

            await _signInManager.SignInAsync(user, isPersistent : false);

            StatusMessage = "The external login was removed.";
            return(RedirectToAction(nameof(ExternalLogins)));
        }
コード例 #13
0
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'ExternalLoginsModel.OnPostRemoveLoginAsync(string, string)'
        public async Task <IActionResult> OnPostRemoveLoginAsync(string loginProvider, string providerKey)
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'ExternalLoginsModel.OnPostRemoveLoginAsync(string, string)'
        {
            var user = await _userManager.GetUserAsync(User);

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

            var result = await _userManager.RemoveLoginAsync(user, loginProvider, providerKey);

            if (!result.Succeeded)
            {
                var userId = await _userManager.GetUserIdAsync(user);

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

            await _signInManager.RefreshSignInAsync(user);

            StatusMessage = "The external login was removed.";
            return(RedirectToPage());
        }
コード例 #14
0
        public async Task<ActionResult> DeleteConfirmed(string id) {

            var roleStore = new RoleStore<IdentityRole>(db);
            var roleManager = new RoleManager<IdentityRole>(roleStore);

            var userStore = new UserStore<ApplicationUser>(db);
            var userManager = new UserManager<ApplicationUser>(userStore);

            if (ModelState.IsValid) {
                if (id == null) {
                    return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
                }

                var user = await userManager.FindByIdAsync(id);
                
                // ev. 3parts inloggningar
                var logins = user.Logins;
                foreach (var login in logins.ToList()) {
                    await userManager.RemoveLoginAsync(login.UserId, new UserLoginInfo(login.LoginProvider, login.ProviderKey));
                }

                var rolesForUser = await userManager.GetRolesAsync(id);

                if (rolesForUser.Count() > 0) {
                    foreach (var item in rolesForUser.ToList()) {
                        // item should be the name of the role
                        var result = await userManager.RemoveFromRoleAsync(user.Id, item);
                    }
                }

                if (user.Documents.Count() > 0) {
                    foreach (var doc in user.Documents.ToList()) {
                        db.Documents.Remove(doc);
                    }
                }

                await userManager.DeleteAsync(user);

                return RedirectToAction("Index");
            }
            else {
                return View();
            }
        }
コード例 #15
0
 public async Task RemoveLoginAsync(string userId, UserLoginDB login)
 {
     var userLoginInfo = new UserLoginInfo(login.LoginProvider, login.ProviderKey);
     await _manager.RemoveLoginAsync(userId, userLoginInfo).ConfigureAwait(false);
 }
コード例 #16
0
 public Task <IActionResult> RemoveLogin(RemoveLoginModel model)
 {
     return(MakeChangeAsync(user => userManager.RemoveLoginAsync(user.Identity, model.LoginProvider, model.ProviderKey),
                            "Login provider removed successfully."));
 }
コード例 #17
0
 public Task <IActionResult> RemoveLogin(RemoveLoginModel model)
 {
     return(MakeChangeAsync(u => userManager.RemoveLoginAsync(u, model.LoginProvider, model.ProviderKey),
                            T.Get("users.profile.removeLoginDone"), model));
 }
コード例 #18
0
    public virtual async Task UpdateUserAsync(IdentityUser user, string providerName)
    {
        await IdentityOptions.SetAsync();

        var externalUser = await GetUserInfoAsync(user);

        NormalizeExternalLoginUserInfo(externalUser, user.UserName);

        if (!externalUser.Name.IsNullOrWhiteSpace())
        {
            user.Name = externalUser.Name;
        }

        if (!externalUser.Surname.IsNullOrWhiteSpace())
        {
            user.Surname = externalUser.Surname;
        }

        if (user.PhoneNumber != externalUser.PhoneNumber)
        {
            if (!externalUser.PhoneNumber.IsNullOrWhiteSpace())
            {
                await UserManager.SetPhoneNumberAsync(user, externalUser.PhoneNumber);

                user.SetPhoneNumberConfirmed(externalUser.PhoneNumberConfirmed == true);
            }
        }
        else
        {
            if (!user.PhoneNumber.IsNullOrWhiteSpace() &&
                user.PhoneNumberConfirmed == false &&
                externalUser.PhoneNumberConfirmed == true)
            {
                user.SetPhoneNumberConfirmed(true);
            }
        }

        if (!string.Equals(user.Email, externalUser.Email, StringComparison.OrdinalIgnoreCase))
        {
            (await UserManager.SetEmailAsync(user, externalUser.Email)).CheckErrors();
            user.SetEmailConfirmed(externalUser.EmailConfirmed ?? false);
        }

        if (externalUser.TwoFactorEnabled != null)
        {
            (await UserManager.SetTwoFactorEnabledAsync(user, externalUser.TwoFactorEnabled.Value)).CheckErrors();
        }

        await IdentityUserRepository.EnsureCollectionLoadedAsync(user, u => u.Logins);

        var userLogin = user.Logins.FirstOrDefault(l => l.LoginProvider == providerName);

        if (userLogin != null)
        {
            if (userLogin.ProviderKey != externalUser.ProviderKey)
            {
                (await UserManager.RemoveLoginAsync(user, providerName, userLogin.ProviderKey)).CheckErrors();
                (await UserManager.AddLoginAsync(user, new UserLoginInfo(providerName, externalUser.ProviderKey, providerName))).CheckErrors();
            }
        }
        else
        {
            (await UserManager.AddLoginAsync(user, new UserLoginInfo(providerName, externalUser.ProviderKey, providerName))).CheckErrors();
        }

        user.IsExternal = true;

        (await UserManager.UpdateAsync(user)).CheckErrors();
    }
コード例 #19
0
        public async Task <ActionResult> Create(RegisterViewModel userViewModel, string[] garages)
        {
            GreenProDbEntities db = new GreenProDbEntities();
            //Find Role Name
            var rolename = db.AspNetRoles.FirstOrDefault(a => a.Id == userViewModel.RoleId);

            //If admin Garage Check

            ModelState.Remove("Email");
            userViewModel.Email = userViewModel.UserName;
            if (rolename != null && (garages == null && rolename.Name != "Admin"))
            {
                ViewBag.StateId      = new SelectList(db.States, "Id", "StateName");
                ViewBag.CityId       = new SelectList(db.Cities, "Id", "CityName");
                ViewBag.RoleId       = new SelectList(db.AspNetRoles, "Id", "Name");
                ViewBag.Garages      = db.Garages.ToList();
                ViewBag.ErrorMessage = "Please select garages for user";
                return(View());
            }
            else if (ModelState.IsValid)
            {
                //Create User
                var user = new ApplicationUser()
                {
                    Email = userViewModel.UserName, UserName = userViewModel.UserName, FirstName = userViewModel.FirstName, LastName = userViewModel.LastName, DateofBirth = userViewModel.DateofBirth, Address = userViewModel.Address, State = userViewModel.StateId, City = userViewModel.CityId, Pincode = userViewModel.Pincode, EmailConfirmed = true
                };
                var isUSer = UserManager.FindByEmail(user.Email);
                if (isUSer == null)
                {
                    var adminresult = UserManager.Create(user, userViewModel.Password);
                    if (adminresult.Succeeded)
                    {
                        var userdetails = db.AspNetUsers.FirstOrDefault(a => a.Id == user.Id);
                        if (userdetails != null)
                        {
                            if (rolename != null)
                            {
                                var result = UserManager.AddToRole(userdetails.Id, rolename.Name);
                                if (result.Succeeded)
                                {
                                    if (rolename.Name != "Admin")
                                    {
                                        //add user to garagaes
                                        if (garages != null)
                                        {
                                            foreach (var item in garages)
                                            {
                                                bool         isLeader = rolename.Name == "Crew Leader";
                                                WorkerGarage worker   = new WorkerGarage {
                                                    GarageID = Convert.ToInt32(item), CrewLeaderId = user.Id, IsLeader = isLeader
                                                };
                                                db.WorkerGarages.Add(worker);
                                            }
                                        }
                                        await db.SaveChangesAsync();
                                    }
                                }
                                else
                                {
                                    var logins = user.Logins;
                                    foreach (var item in logins.ToList())
                                    {
                                        await UserManager.RemoveLoginAsync(item.UserId, new UserLoginInfo(item.LoginProvider, item.ProviderKey));
                                    }
                                }
                            }
                        }
                        AddNotification(Models.NotifyType.Success, "Records Successfully Saved", true);
                        return(RedirectToAction("Index", "UsersAdmin"));
                    }
                }
                else
                {
                    ViewBag.ErrorMessage = "User Already Exist's !";
                    ErrorNotification("User Already Exist's !");
                }
            }

            ViewBag.StateId = new SelectList(db.States, "Id", "StateName");
            ViewBag.CityId  = new SelectList(db.Cities, "Id", "CityName");
            ViewBag.RoleId  = new SelectList(db.AspNetRoles, "Id", "Name");
            ViewBag.Garages = db.Garages.ToList();

            return(View());
        }
コード例 #20
0
 public Task <IdentityResult> RemoveLoginAsync(T user, string loginProvider, string providerKey)
 {
     return(u.RemoveLoginAsync(user, loginProvider, providerKey));
 }