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);
}
