public async Task <IdentityResult> UpdateClaimAsync(string userId, Claim claim) { var cls = _userManager.GetClaims(userId).Where(x => x.Type == claim.Type); foreach (var c in cls) { _userManager.RemoveClaim(userId, c); } var result = await _userManager.AddClaimAsync(userId, claim); return(result); }
public void SavePermission(IEnumerable <string> selected) { var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>()); var principal = HttpContext.User.Identity as ClaimsIdentity; var userid = principal.GetUserId(); using (var context = new ApplicationDbContext()) { var allroles = context.Roles.ToList(); var userClaims = userManager.GetClaims(userid).ToList(); //remove all existing user claims foreach (var claim in userClaims) { userManager.RemoveClaim(userid, claim); } //add new selected claims foreach (var roleid in selected) { var role = allroles.Single(r => r.Id == roleid); userManager.AddClaim(userid, new Claim(ClaimTypes.Role, role.Name)); } } }
public ActionResult DeleteUserConfirmed(string id = null) { try { IdentityContext IdentityContext1 = new IdentityContext(); ApplicationUser IdentityUser1 = IdentityContext1.Users.First(x => x.Id == id); UserManager <ApplicationUser> UserManager1 = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new IdentityContext())); foreach (string UserRole1 in UserManager1.GetRoles(id)) { UserManager1.RemoveFromRole(id, UserRole1); } foreach (System.Security.Claims.Claim UserClaim1 in UserManager1.GetClaims(id)) { UserManager1.RemoveClaim(id, UserClaim1); } foreach (UserLoginInfo UserLoginInfo1 in UserManager1.GetLogins(id)) { UserManager1.RemoveLogin(id, UserLoginInfo1); } IdentityContext1.Users.Remove(IdentityUser1); IdentityContext1.SaveChanges(); //return RedirectToAction("AllUsers"); return(Json(new { success = true })); } catch (Exception ex) { return(Content(ex.Message)); } }
public async Task <IHttpActionResult> AddClaimToUser(UserClaimBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userId = model.UserId; var claimType = model.Type; var claimValue = model.Value; ApplicationUser user = UserManager.FindById(userId); if (user == null) { return(BadRequest("The user id does not exist: \"" + userId + "\"")); } foreach (var claim in UserManager.GetClaims(user.Id).Where(c => c.Type == claimType)) { UserManager.RemoveClaim(user.Id, claim); } var result = await UserManager.AddClaimAsync(user.Id, new Claim(claimType, claimValue)); if (!result.Succeeded) { return(GetErrorResult(result)); } return(Ok()); }
public ActionResult UpdateProfile_Post(UpdateUserProfileModel model) { try { var currentIdentity = HttpContext.User.Identity as ClaimsIdentity; var avatarClaim = currentIdentity.FindFirst(ClaimKeys.Avatar); if (avatarClaim != null) { currentIdentity.RemoveClaim(avatarClaim); UserManager.RemoveClaim(model.UserId, avatarClaim); } currentIdentity.AddClaim(new Claim(ClaimKeys.Avatar, model.Avatar)); UserManager.AddClaim(model.UserId, new Claim(ClaimKeys.Avatar, model.Avatar)); var authenticationManager = System.Web.HttpContext.Current.GetOwinContext().Authentication; authenticationManager.AuthenticationResponseGrant = new AuthenticationResponseGrant(new ClaimsPrincipal(currentIdentity), new AuthenticationProperties() { IsPersistent = true }); this.AddNotification("Update profile successfully", NotificationType.SUCCESS); } catch (Exception ex) { this.AddNotification("System is busy now. Please try again later", NotificationType.ERROR); var strError = string.Format("Could not UpdateProfile because: {0}", ex.ToString()); logger.Error(strError); return(View(model)); } return(View(model)); }
public static bool DeleteUserClaims(string userName) { var isRemove = true; var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext)); var userASP = userManager.FindByEmail(userName); if (userASP == null) { return(false); } var claims = userManager.GetClaims(userASP.Id); foreach (var claim in claims) { var response = userManager.RemoveClaim(userASP.Id, claim); if (!response.Succeeded) { isRemove = false; } } return(isRemove); }
public void RemoveUserClaimSyncTest() { var db = UnitTestHelper.CreateDefaultDb(); var manager = new UserManager <IdentityUser>(new UserStore <IdentityUser>(db)); var user = new IdentityUser("u1"); var result = manager.Create(user); Assert.NotNull(user); var claims = new[] { new Claim("c1", "v1"), new Claim("c2", "v2"), new Claim("c3", "v3") }; foreach (Claim c in claims) { UnitTestHelper.IsSuccess(manager.AddClaim(user.Id, c)); } var userClaims = new List <Claim>(manager.GetClaims(user.Id)); Assert.Equal(3, userClaims.Count); foreach (Claim c in claims) { Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value)); UnitTestHelper.IsSuccess(manager.RemoveClaim(user.Id, c)); } var cs = manager.GetClaims(user.Id); Assert.Equal(0, cs.Count()); Assert.Equal(0, db.Set <IdentityUserClaim>().Count()); }
public ActionResult Edit(UserViewModel model) { try { var _connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString.ToString(); using (SqlConnection connection = new SqlConnection(_connectionString)) { connection.Open(); var _userClaims = _UserClaimsRepository.GetAll().Where(x => x.User.Id == model.UserId).ToList(); foreach (var item in model.Claims) { var _user = UserManager.FindById(model.UserId); var _ExistingClaim = _userClaims.Where(x => x.ClaimValue.ToLower() == item.ClaimValue.ToLower()).FirstOrDefault(); if (_ExistingClaim == null && item.IsChecked == true) { String query = "INSERT INTO [dbo].[AspNetUserClaims]([ClaimType],[ClaimValue],[UserId],[ClaimID],[IsActive],[DisplayLabel],[Discriminator],[User_Id]) VALUES(@ClaimType,@ClaimValue,@UserId,@ClaimID,@IsActive,@DisplayLabel,@Discriminator,@User_Id)"; using (SqlCommand command = new SqlCommand(query, connection)) { command.Parameters.AddWithValue("@ClaimType", item.ClaimType); command.Parameters.AddWithValue("@ClaimValue", item.ClaimValue); command.Parameters.AddWithValue("@UserId", model.UserId); command.Parameters.AddWithValue("@ClaimID", item.Id); command.Parameters.AddWithValue("@IsActive", "True"); command.Parameters.AddWithValue("@DisplayLabel", item.ClaimValue); command.Parameters.AddWithValue("@Discriminator", "ApplicationUserClaim"); command.Parameters.AddWithValue("@User_Id", model.UserId); int _result = command.ExecuteNonQuery(); if (_result < 0) { Console.WriteLine("Error inserting data into Database!"); } } //var _newClaim = new System.Security.Claims.Claim(item.ClaimType, item.ClaimValue); //UserManager.AddClaim(model.UserId, _newClaim); } if (_ExistingClaim != null && item.IsChecked == false) { var _newClaim = new System.Security.Claims.Claim(_ExistingClaim.ClaimType, _ExistingClaim.ClaimValue); UserManager.RemoveClaim(model.UserId, _newClaim); } } } _UserClaimsRepository.Save(); this.AddNotification("Claims updated successfully.", NotificationType.SUCCESS); return(RedirectToAction("index")); } catch (Exception ex) { throw ex; } }
public void CanDeleteClaim() { var user = CreateBasicUser(); UserManager.AddClaim(user.Id, _basicClaim); var claims = UserManager.GetClaims(user.Id); claims.Count.ShouldBe(1); UserManager.RemoveClaim(user.Id, _basicClaim); UserManager.GetClaims(user.Id).Count.ShouldBe(0); }
public void RemoveClaimShouldRemoveClaimFromTheUserClaimsCollection() { var user = new IdentityUser(GetNewRandomName()); _userManager.Create(user); var claimToAddAndRemove = new Claim(ClaimTypes.Role, "Customer"); _userManager.AddClaim(user.Id, claimToAddAndRemove); _userManager.RemoveClaim(user.Id, claimToAddAndRemove); var userClaims = _userManager.GetClaims(user.Id); Assert.AreEqual(0, userClaims.Count); }
public void DeleteUserClaim(int userId, List <ApplicationUserClaim> claims) { var claimsAll = _userManager.GetClaims(userId); var claimFilter = claims? .Select(c => claimsAll.FirstOrDefault(d => d.Type == c.ClaimType && d.Value == c.ClaimValue)) .ToList(); foreach (var item in claimFilter) { if (item != null) { _userManager.RemoveClaim(userId, item); } } }
public JsonResult chuyentheme(string theme) { var user = kiemtra.getUser(User.Identity.Name); var userstore = new UserStore <ApplicationUser>(db); var userManager = new UserManager <ApplicationUser>(userstore); var userid = db.TaiKhoans.FirstOrDefault(x => x.UserName.Equals(user.UserName)).Id; var claim = userManager.GetClaims(userid).FirstOrDefault(x => x.Type.Equals("MyApp:ThemeUrl")); if (claim != null) { userManager.RemoveClaim(userid, claim); } userManager.AddClaim(userid, new Claim("MyApp:ThemeUrl", theme)); return(Json(new object { })); }
public void SignOut() { var loginInfo = this.GetExternalLoginInfo(); var loggedUserId = GetLoginUserId(); //Here we are removing user claims if exist if (loginInfo != null && loginInfo.ExternalIdentity.IsAuthenticated) { string userId = loginInfo.ExternalIdentity.Claims.First(c => c.Type.Equals("UserId")).Value; foreach (var claim in loginInfo.ExternalIdentity.Claims) { UserManager.RemoveClaim(Convert.ToInt32(userId), claim); } } string[] types = new string[] { DefaultAuthenticationTypes.ExternalBearer, DefaultAuthenticationTypes.ExternalCookie }; SignInManager.AuthenticationManager.SignOut(types); }
public IdentityResult RemoveUserClaim(string userId, string claimType) { _userManager.UserValidator = new UserValidator <ApplicationUser>(_userManager) { AllowOnlyAlphanumericUserNames = false, RequireUniqueEmail = true }; var claim = _userManager.GetClaims(userId).FirstOrDefault(t => t.Type == claimType); if (claim == null) { return(IdentityResult.Success); } return(_userManager.RemoveClaim(userId, claim)); }
protected void UpdateRoles_Click(object sender, EventArgs e) { Button btn = sender as Button; var userStore = new UserStore <IdentityUser>(); var manager = new UserManager <IdentityUser>(userStore); var updateUser = manager.FindById(btn.CommandArgument); //Remove the user from the currently selected role var roles = manager.GetRoles(updateUser.Id); if (roles.Count > 0) { foreach (var role in roles) { manager.RemoveFromRole(updateUser.Id, role); } var claims = manager.GetClaims(updateUser.Id); foreach (var claim in claims) { manager.RemoveClaim(updateUser.Id, claim); } } var selectedRoles = Roles_List.Items .Cast <ListItem>() .Where(n => n.Selected) .ToList(); if (selectedRoles.Count > 0) { foreach (var selectedRole in selectedRoles) { manager.AddToRole(updateUser.Id, selectedRole.Text.Trim()); } } ScriptManager.RegisterStartupScript(Page, Page.GetType(), "updateRolesModal", "$('#updateRolesModal').modal('hide');", true); }
public IHttpActionResult Delete(Account account) { //if (!ModelState.IsValid) //{ // return BadRequest(ModelState); //} if (GetLoggedInEmail() != account.Email) { return(BadRequest("Deleting user other than self")); } //if (!role.Equals("student") && !role.Equals("teacher")/* && !role.Equals("employee")*/) //{ // return BadRequest(role); //} // actually register var userStore = new UserStore <IdentityUser>(new IdentityContext()); var userManager = new UserManager <IdentityUser>(userStore); var user = userManager.Users.FirstOrDefault(u => u.UserName == account.Email); if (user == null) { return(BadRequest()); } userManager.RemoveClaim(user.Id, userManager.GetClaims(user.Id).FirstOrDefault()); userManager.Delete(user); //login //var authManager = Request.GetOwinContext().Authentication; //var claimsIdentity = userManager.CreateIdentity(user, WebApiConfig.AuthenticationType); //authManager.SignIn(new AuthenticationProperties { IsPersistent = true }, claimsIdentity); Request.GetOwinContext().Authentication.SignOut(WebApiConfig.AuthenticationType); return(Ok()); }
public HttpResponseMessage UpdateUserInfo(UpdateUserBindingModel model) { if (!ModelState.IsValid) { return(Request.CreateResponse(System.Net.HttpStatusCode.BadRequest, ModelState)); } var user = UserManager.FindById(model.Id); user.Email = model.Email; var personNameClaim = user.Claims.FirstOrDefault(n => n.ClaimType == "personNameId"); if (personNameClaim != null) { int personNameId = Convert.ToInt32(personNameClaim.ClaimValue); new PersonNameRepo().Update(new PersonName(personNameId, model.FirstName, model.LastName)); } else { var newPersonName = new PersonName(model.FirstName, model.LastName); new PersonNameRepo().Add(newPersonName); foreach (var claim in UserManager.GetClaims(user.Id).Where(c => c.Type == "personNameId")) { UserManager.RemoveClaim(user.Id, claim); } UserManager.AddClaim(user.Id, new Claim("personNameId", newPersonName.Id.ToString())); } foreach (var claim in UserManager.GetClaims(user.Id).Where(c => c.Type == "organizationId")) { UserManager.RemoveClaim(user.Id, claim); } UserManager.AddClaim(user.Id, new Claim("organizationId", model.OrganizationId.ToString())); return(Request.CreateResponse(System.Net.HttpStatusCode.OK, GetUser(user))); }
static void Main(string[] args) { DbContext ctx = new IdentityDbContext("DefaultConnectionString"); //ctx.Database.Connection.Open(); var username = "******"; var password = "******"; var userStore = new UserStore <IdentityUser>(); var userManager = new UserManager <IdentityUser>(userStore); // Create new user var creationResult = userManager.Create(new IdentityUser(username), password); Console.WriteLine($"{creationResult.Succeeded}. {creationResult.Errors.Aggregate("Reason: ",(e, f) => e + f)}"); // Get user to get user's id and other properties var user = userManager.FindByName(username); // Remove claim var removeClaimResult = userManager.RemoveClaim(user.Id, new Claim("given_name", "MrClan")); // Create new claim for the user var claimResult = userManager.AddClaim(user.Id, new Claim("given_name", "MrClan")); Console.WriteLine($"Claim: {claimResult.Succeeded}"); // verify user password var isMatch = userManager.CheckPassword(user, password); Console.WriteLine($"Password Matches: {isMatch}"); Console.ReadKey(); }
public IHttpActionResult DeleteUserClaim(DeleteUserClaimBindingModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userId = model.UserId; var claimType = model.Type; ApplicationUser user = UserManager.FindById(userId); if (user == null) { return(BadRequest("The user id does not exist: \"" + userId + "\"")); } foreach (var claim in UserManager.GetClaims(user.Id).Where(c => c.Type == claimType)) { UserManager.RemoveClaim(user.Id, claim); } return(Ok()); }
public static bool UpdateUserClaims(UserRequest user) { var isRemove = true; var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext)); var userASP = userManager.FindByEmail(user.EMail); if (userASP == null) { return(false); } var claims = userManager.GetClaims(userASP.Id); if (!string.IsNullOrEmpty(user.FirstName)) { var nameClaim = GetClaimByType(claims, ClaimTypes.GivenName); if (nameClaim != null) { userManager.RemoveClaim(userASP.Id, (System.Security.Claims.Claim)nameClaim); } userManager.AddClaim(userASP.Id, new System.Security.Claims.Claim(ClaimTypes.GivenName, user.FirstName)); } if (!string.IsNullOrEmpty(user.LastName)) { var lastnameClaim = GetClaimByType(claims, ClaimTypes.Name); if (lastnameClaim != null) { userManager.RemoveClaim(userASP.Id, (System.Security.Claims.Claim)lastnameClaim); } userManager.AddClaim(userASP.Id, new System.Security.Claims.Claim(ClaimTypes.Name, user.LastName)); } if (user.ImageArray != null && user.ImageArray.Length > 0) { var imageClaim = GetClaimByType(claims, ClaimTypes.Uri); if (imageClaim != null) { userManager.RemoveClaim(userASP.Id, (System.Security.Claims.Claim)imageClaim); } var stream = new MemoryStream(user.ImageArray); var guid = Guid.NewGuid().ToString(); var file = $"{guid}.jpg"; var folder = "~/Content/Users"; var fullPath = $"{folder}/{file}"; var response = FilesHelper.UploadPhoto(stream, folder, file); if (response) { user.ImagePath = fullPath; } userManager.AddClaim(userASP.Id, new System.Security.Claims.Claim(ClaimTypes.Uri, user.ImagePath)); } userASP.EmailConfirmed = true; return(isRemove); }
protected void UpdateClaims_Click(object sender, EventArgs e) { Button btn = sender as Button; var userStore = new UserStore <IdentityUser>(); var manager = new UserManager <IdentityUser>(userStore); var updateUser = manager.FindById(btn.CommandArgument); var claims = manager.GetClaims(updateUser.Id); if (manager.IsInRole(updateUser.Id, "Pillar")) { foreach (var claim in claims) { manager.RemoveClaim(updateUser.Id, claim); } var selectedClaims = Pillar_List.Items .Cast <ListItem>() .Where(n => n.Selected) .ToList(); if (selectedClaims.Count == 0) { ScriptManager.RegisterStartupScript(Page, Page.GetType(), "infoModal", "$('#infoModal').modal();", true); } else { foreach (var selectedClaim in selectedClaims) { manager.AddClaim(updateUser.Id, new Claim("Pillar", selectedClaim.Value)); } } } else if (manager.IsInRole(updateUser.Id, "Partner")) { foreach (var claim in claims) { manager.RemoveClaim(updateUser.Id, claim); } var selectedClaims = Implementing_Partner_List.Items .Cast <ListItem>() .Where(n => n.Selected) .ToList(); if (selectedClaims.Count == 0) { ScriptManager.RegisterStartupScript(Page, Page.GetType(), "infoModal", "$('#infoModal').modal();", true); } else { foreach (var selectedClaim in selectedClaims) { manager.AddClaim(updateUser.Id, new Claim("Project", selectedClaim.Value)); //To update the User (Not Needed though) //manager.Update(updateUser); } } } ScriptManager.RegisterStartupScript(Page, Page.GetType(), "updateClaimsModal", "$('#updateClaimsModal').modal('hide');", true); }
public void RemoveUserClaimSyncTest() { var db = UnitTestHelper.CreateDefaultDb(); var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db)); var user = new IdentityUser("u1"); var result = manager.Create(user); Assert.NotNull(user); var claims = new[] { new Claim("c1", "v1"), new Claim("c2", "v2"), new Claim("c3", "v3") }; foreach (Claim c in claims) { UnitTestHelper.IsSuccess(manager.AddClaim(user.Id, c)); } var userClaims = new List<Claim>(manager.GetClaims(user.Id)); Assert.Equal(3, userClaims.Count); foreach (Claim c in claims) { Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value)); UnitTestHelper.IsSuccess(manager.RemoveClaim(user.Id, c)); } var cs = manager.GetClaims(user.Id); Assert.Equal(0, cs.Count()); Assert.Equal(0, db.Set<IdentityUserClaim>().Count()); }
public static async Task UpdateModeratedSubreddits( Models.ApplicationUser ident, UserManager<Models.ApplicationUser> manager ) { string cabalSubName = System.Configuration.ConfigurationManager.AppSettings["CabalSubreddit"].ToLower(); if ( ident.TokenExpires < DateTime.UtcNow ) { GetNewToken( ident ); } Utilities.SNWebAgent agent = new SNWebAgent( ident.AccessToken ); RedditSharp.Reddit rd = new RedditSharp.Reddit( agent, true ); var subs = rd.User.ModeratorSubreddits.ToList<RedditSharp.Things.Subreddit>(); List<string> currentRoles = ident.Claims.Where( x => x.ClaimType == roleType ).Select( r => r.ClaimValue ).ToList<string>(); List<Models.Subreddit> activeSubs = await new BLL.SubredditBLL().GetActiveSubs(); List<string> activeSubNames = activeSubs.Select( s => s.SubName.ToLower() ).ToList(); List<IdentityUserClaim> currentAdminRoles = ident.Claims.Where( c => c.ClaimType.StartsWith( "urn:snoonotes:subreddits:" ) ).ToList(); List<Claim> rolesToAdd = new List<Claim>(); List<Claim> rolesToRemove = new List<Claim>(); foreach ( string role in currentRoles ) { var sub = subs.Find( s => s.Name.ToLower() == role ); if ( activeSubNames.Contains( role ) ) { if ( sub != null ) { //if they already have the role and they still have the correct access if ( sub.ModPermissions.HasFlag( RedditSharp.ModeratorPermission.All ) || ( (int) sub.ModPermissions & activeSubs.Where( s => s.SubName.ToLower() == role ).Select( s => s.Settings.AccessMask ).First() ) > 0 ) { //Check if "full" permissions if ( sub.ModPermissions.HasFlag( RedditSharp.ModeratorPermission.All ) && !ClaimsPrincipal.Current.HasClaim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ) { //has admin permissions but doesn't have role, so add it rolesToAdd.Add( new Claim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ); } else if ( !sub.ModPermissions.HasFlag( RedditSharp.ModeratorPermission.All ) && ClaimsPrincipal.Current.HasClaim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ) { //doesn't have admin permission, but does have role, so remove it rolesToRemove.Add( new Claim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ); } } else { //lost da permissions rolesToRemove.Add( new Claim( roleType, role ) ); if ( !sub.ModPermissions.HasFlag( RedditSharp.ModeratorPermission.All ) && ClaimsPrincipal.Current.HasClaim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ) rolesToRemove.Add( new Claim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ); } //User already has sub as a role and is still a mod subs.Remove( sub ); } else { rolesToRemove.Add( new Claim( roleType, role ) ); } } else { //sub was deactivated, add it to remove. rolesToRemove.Add( new Claim( roleType, role ) ); if ( ClaimsPrincipal.Current.HasClaim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ) rolesToRemove.Add( new Claim( "urn:snoonotes:subreddits:" + role + ":admin", "true" ) ); } } //subs now only contains subs that don't exist as roles foreach ( RedditSharp.Things.Subreddit sub in subs ) { string subname = sub.Name.ToLower(); if ( activeSubNames.Contains( subname ) ) { if ( sub.ModPermissions.HasFlag( RedditSharp.ModeratorPermission.All ) ) { rolesToAdd.Add( new Claim( roleType, subname ) ); rolesToAdd.Add( new Claim( "urn:snoonotes:subreddits:" + subname + ":admin", "true" ) ); } else if ( ( (int) sub.ModPermissions & activeSubs.Where( s => s.SubName.ToLower() == subname ).Select( s => s.Settings.AccessMask ).First() ) > 0 ) { rolesToAdd.Add( new Claim( roleType, subname ) ); } } } foreach ( var adminRole in currentAdminRoles ) { string subName = adminRole.ClaimType.Replace( "urn:snoonotes:subreddits:", "" ).Replace( ":admin", "" ).ToLower(); if ( subs.Exists( s => s.Name.ToLower() == subName && !s.ModPermissions.HasFlag( RedditSharp.ModeratorPermission.All ) ) ) { ident.Claims.Remove( adminRole ); } } string cabalUserName = System.Configuration.ConfigurationManager.AppSettings["CabalUsername"]; var cabalUser = HttpContext.Current.GetOwinContext().GetUserManager<ApplicationUserManager>().FindByName( cabalUserName ); if(cabalUser.TokenExpires < DateTime.UtcNow ) { GetNewToken( cabalUser ); } agent = new SNWebAgent( cabalUser.AccessToken ); RedditSharp.Reddit reddit = new RedditSharp.Reddit( agent, false ); var redditSub = reddit.GetSubreddit( cabalSubName ); var contribs = redditSub.Contributors; if(contribs.Any(c=>c.Name.ToLower() == ident.UserName.ToLower() ) ) { var cabalClaim = new Claim( roleType, cabalSubName ); rolesToRemove.RemoveAll( r => r.Type == cabalClaim.Type && r.Value == cabalClaim.Value ); if ( !currentRoles.Contains( cabalSubName ) && !rolesToAdd.Any(ar => ar.Value == cabalClaim.Value && ar.Type == cabalClaim.Type)) { rolesToAdd.Add( cabalClaim ); } } foreach ( Claim c in rolesToRemove ) { manager.RemoveClaim( ident.Id, c ); //ident.Claims.Remove( ident.Claims.First( uc => uc.UserId == ident.Id && uc.ClaimType == c.Type && uc.ClaimValue == c.Value ) ); } foreach ( Claim c in rolesToAdd ) { //manager.AddClaim( ident.Id, c ); ident.Claims.Add( new IdentityUserClaim() { ClaimType = c.Type, ClaimValue = c.Value, UserId = ident.Id } ); } }
private void AddRemoveClaims(string userID, List <Claim> userClaims, string selectedClaims, string type) { if (selectedClaims == null) { if (userClaims.Count > 0) { userClaims.ForEach(x => { _mgr.RemoveClaim(userID, x); }); } } else { var arraySelectedClaims = selectedClaims.Split(','); if (userClaims.Count == 0) { Array.ForEach(arraySelectedClaims, x => { _mgr.AddClaim(userID, new Claim(type, x)); }); } else { if (userClaims.Count > arraySelectedClaims.Count()) { userClaims.ForEach(x => { if (!arraySelectedClaims.Contains(x.Value)) { _mgr.RemoveClaim(userID, x); } }); } else if (userClaims.Count < arraySelectedClaims.Count()) { Array.ForEach(arraySelectedClaims, x => { if (!userClaims.Exists(y => y.Value == x)) { //var currentClaim = userClaims.FirstOrDefault(c => c.Value == x); _mgr.AddClaim(userID, new Claim(type, x)); } }); } else { var existingClaims = new List <string>(); Array.ForEach(arraySelectedClaims, x => { if (!userClaims.Exists(y => y.Value == x)) { _mgr.AddClaim(userID, new Claim(type, x)); } existingClaims.Add(x); }); Array.ForEach(userClaims.ToArray(), r => { if (!existingClaims.Exists(q => q == r.Value)) { _mgr.RemoveClaim(userID, r); } }); } } } }
public ActionResult TeacherRemove(User input) { UserManager manager = new UserManager(); User user = manager.findById(input.Id); if (ModelState.IsValid) { manager.RemoveClaim(input.Id, new Claim(ClaimTypes.Role, "teacher")); return RedirectToAction("Index"); } return View(user); }