public async Task DupeUserClaimTest()
{
var db = UnitTestHelper.CreateDefaultDb();
var manager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(db));
var user = new IdentityUser("u1");
var result = await manager.CreateAsync(user);
Assert.NotNull(user);
var claims = new[]
{
new Claim("c1", "v1"),
new Claim("c2", "v2"),
new Claim("c3", "v3")
};
foreach (Claim c in claims)
{
// Add dupes
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
UnitTestHelper.IsSuccess(await manager.AddClaimAsync(user.Id, c));
}
var userClaims = new List<Claim>(await manager.GetClaimsAsync(user.Id));
Assert.Equal(6, userClaims.Count);
var currentExpected = 6;
foreach (Claim c in claims)
{
Assert.True(userClaims.Exists(u => u.Type == c.Type && u.Value == c.Value));
UnitTestHelper.IsSuccess(await manager.RemoveClaimAsync(user.Id, c));
var cs = await manager.GetClaimsAsync(user.Id);
currentExpected -= 2;
Assert.Equal(currentExpected, cs.Count());
Assert.Equal(currentExpected, db.Set<IdentityUserClaim>().Count());
}
}
public async Task Delete(int? gameID)
{
if (gameID == null)
{
throw new ArgumentNullException("gameID");
}
var id = gameID.Value;
var game = await db.Games.FindAsync(id);
if (game == null)
{
throw new ArgumentException("Could not find game with id " + id);
}
var userID = this.User.Identity.GetUserId();
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(this.db));
var appUser = await manager.FindByIdAsync(this.User.Identity.GetUserId());
if (!DoesUserOwnGame(appUser, id))
{
throw new ArgumentException("Could not delete game");
}
var memberships = await db.GameMemberships.Where(m => m.GameID == id).Include(m => m.ApplicationUser).ToListAsync();
var claims = await Task.WhenAll(memberships.Select(m => m.ApplicationUser).Select(user =>
manager.GetClaimsAsync(user.Id).ContinueWith(t => new { Claims = t.Result, User = user })));
var strId = id.ToString();
var removeTasks = from tuple in claims
from claim in tuple.Claims
where (claim.Type == "GameOwnership" || claim.Type == "GameOwnership" || claim.Type == "GameMaster") && claim.Value == strId
select manager.RemoveClaimAsync(tuple.User.Id, claim);
await Task.WhenAll(removeTasks);
db.GameMemberships.RemoveRange(memberships);
db.Games.Remove(game);
await db.SaveChangesAsync();
}
//[Authorize(Policy = Constante.UsuarioCanUpdate)]
public async Task <IActionResult> Editar(PerfilUsuario model)
{
//var editar = model.EditarUsuarioModel;
//MensajesViewModel mensaje = new MensajesViewModel();
if (TryValidateModel(model.EditarUsuarioModel))
{
var usuarioCreado = _usuario.GetUsuarioById(model.EditarUsuarioModel.Id);
//var roleslist = _roleManger.Roles.ToList();
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
Usuario user = _userManager.FindByIdAsync(userId).Result;
//var claims = User.Claims.ToList();
//var claimsPrueba = User.Claims.ToList().FirstOrDefault(x=> x.Value == usuarioCreado.Role);
//foreach (var role in roleslist)
//{
// foreach(var claim in claims)
// {
// await _roleManger.RemoveClaimAsync(role, claim);
// }
//}
var claims = User.Claims.ToList();;
var lastAccessedClaim = claims.ToList();
foreach (var claim in claims)
{
var resDelete = (lastAccessedClaim == null) ? null : await _userManager.RemoveClaimAsync(user, claim);
var prueba = "";
}
var claimsPrueba = User.Claims.ToList();
PropertiesParser <EditarUsuarioModel, Usuario>
.CopyPropertiesTo <EditarUsuarioModel, Usuario>(model.EditarUsuarioModel, usuarioCreado);
await _userManager.UpdateAsync(usuarioCreado);
var roles = await _userManager.GetRolesAsync(usuarioCreado);
if (!string.IsNullOrEmpty(model.EditarUsuarioModel.Role))
{
if (!roles.Contains(model.EditarUsuarioModel.Role))
{
await _userManager.AddToRoleAsync(usuarioCreado, model.EditarUsuarioModel.Role);
}
}
//mensaje.Titulo = "Usuario Actualizado";
//mensaje.Texto = usuarioCreado.Nombre + " " + usuarioCreado.Apellido + "ha sido actualizado correctamente";
//mensaje.Tipo = "green";
EnviarMensaje.Enviar(TempData, "green", 3);
return(View("Index", _usuario.Usuarios));
}
//mensaje.Titulo = "Hubo un error";
//mensaje.Texto = "verifique los campos que desea cambiar";
//mensaje.Tipo = "red";
return(View("PerfilUsuario", model));
}
public async Task <IActionResult> Index(IndexViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var email = user.Email;
if (model.Email != email)
{
var setEmailResult = await _userManager.SetEmailAsync(user, model.Email);
if (!setEmailResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'.");
}
}
var phoneNumber = user.PhoneNumber;
if (model.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, model.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'.");
}
}
// check FirstName + LastName
bool updateClaims = false;
if (model.FirstName != user.FirstName || model.LastName != user.LastName)
{
updateClaims = true;
// grab old claim and get rid of it
await _userManager.RemoveClaimAsync(user, new Claim("FullName", user.FirstName + " " + user.LastName));
user.FirstName = model.FirstName;
user.LastName = model.LastName;
// add FullName claim
var nameClaim = new Claim("FullName", model.FirstName + " " + model.LastName);
await _userManager.AddClaimAsync(user, nameClaim);
}
// check IsActive - there is probably a neater way to do this, but I was short on time
var activeClaim = User.FindFirst(Claims.IsActive);
var isActive = (activeClaim.Value != "true" ? false : true);
if (model.IsActive != isActive)
{
var newClaim = new Claim(Claims.IsActive, (model.IsActive == true ? "true" : "false"));
updateClaims = true;
await _userManager.ReplaceClaimAsync(user, activeClaim, newClaim);
}
// check dob
if (model.DateOfBirth != user.DateOfBirth)
{
user.DateOfBirth = model.DateOfBirth;
}
var nameResults = await _userManager.UpdateAsync(user);
if (!nameResults.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting FirstName+LastName for user with ID '{user.Id}'.");
}
// claim changed, so do update
if (updateClaims == true)
{
// refresh claims
await _signInManager.RefreshSignInAsync(user);
}
StatusMessage = "Your profile has been updated";
return(RedirectToAction(nameof(Index)));
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> UpdateProfile([FromBody] UserAccount userAccount)
{
var claims = from c in User.Claims
select new
{
c.Type,
c.Value
};
//var userClaimsToAdd = new List<Claim>
// {
// //new Claim(ClaimTypes.NameIdentifier, userInfoPayload.Name),
// new Claim(IdentityModel.JwtClaimTypes.Name, userInfoPayload.Name),
// new Claim(IdentityModel.JwtClaimTypes.FamilyName, userInfoPayload.FamilyName),
// new Claim(IdentityModel.JwtClaimTypes.GivenName, userInfoPayload.GivenName),
// new Claim(IdentityModel.JwtClaimTypes.Email, userInfoPayload.Email),
// //new Claim(IdentityModel.JwtClaimTypes.Subject, userInfoPayload.Subject),
// new Claim(IdentityModel.JwtClaimTypes.Issuer, userInfoPayload.Issuer),
// new Claim(IdentityModel.JwtClaimTypes.Picture, userInfoPayload.Picture),
// }
//;
AppUser user;
//IEnumerable<Claim> userClaims;
if (!string.IsNullOrEmpty(userAccount.UserId))
{
// so find the user from db to retrieve claims to send into token
user = await _userManager.FindByIdAsync(userAccount.UserId);
//if (user != null)
//{
// // to find the db user claims
// userClaims = await _userManager.GetClaimsAsync(user);
//}
}
else
{
return(BadRequest("userId is not valid!"));
}
if (!string.IsNullOrEmpty(userAccount.Name))
{
// to find the db user claims
var userClaims = await _userManager.GetClaimsAsync(user);
var nameClaim = userClaims.FirstOrDefault(claim => claim.Type.Equals(IdentityModel.JwtClaimTypes.Name));
if (nameClaim != null)
{
var removeClaimResult = await _userManager.RemoveClaimAsync(user, nameClaim);
}
var newNameClaim = new Claim(IdentityModel.JwtClaimTypes.Name, userAccount.Name);
var claimsIdentityResult = await _userManager.AddClaimAsync(user, newNameClaim);
}
if (!string.IsNullOrEmpty(userAccount.Gender))
{
// to find the db user claims
var userClaims = await _userManager.GetClaimsAsync(user);
var genderClaim = userClaims.FirstOrDefault(claim => claim.Type.Equals(IdentityModel.JwtClaimTypes.Gender));
if (genderClaim != null)
{
var removeGenderClaimResult = await _userManager.RemoveClaimAsync(user, genderClaim);
}
var newGenderClaim = new Claim(IdentityModel.JwtClaimTypes.Gender, userAccount.Gender);
var claimsIdentityResult = await _userManager.AddClaimAsync(user, newGenderClaim);
}
if (!string.IsNullOrEmpty(userAccount.DateOfBirth))
{
// to find the db user claims
var userClaims = await _userManager.GetClaimsAsync(user);
var birthDateClaim = userClaims.FirstOrDefault(claim => claim.Type.Equals(IdentityModel.JwtClaimTypes.BirthDate));
if (birthDateClaim != null)
{
var removeBirthDateClaimResult = await _userManager.RemoveClaimAsync(user, birthDateClaim);
}
var newBirthDateClaim = new Claim(IdentityModel.JwtClaimTypes.BirthDate, userAccount.DateOfBirth, ClaimValueTypes.Date);
var claimsIdentityResult = await _userManager.AddClaimAsync(user, newBirthDateClaim);
}
if (!string.IsNullOrEmpty(userAccount.WorkEmail))
{
// to find the db user claims
var userClaims = await _userManager.GetClaimsAsync(user);
var workEmailClaim = userClaims.FirstOrDefault(claim => claim.Type.Equals(CustomClaimsConstants.WorkEmail));
if (workEmailClaim != null)
{
var removeWorkEmailClaimResult = await _userManager.RemoveClaimAsync(user, workEmailClaim);
}
var customClaimWorkEmail = new Claim(CustomClaimsConstants.WorkEmail, userAccount.WorkEmail);
// add work email to user claims
var claimsIdentityResult = await _userManager.AddClaimAsync(user, customClaimWorkEmail);
}
if (!string.IsNullOrEmpty(userAccount.PrimaryEmail))
{
// Update it with the values from the view model
user.Email = userAccount.PrimaryEmail;
}
if (!string.IsNullOrEmpty(userAccount.PhoneNumber))
{
user.PhoneNumber = userAccount.PhoneNumber;
}
await _userManager.UpdateAsync(user);
return(Ok("profile updated"));
}
