// PUT odata/UserClaim(5) public virtual async Task<IHttpActionResult> Put([FromODataUri] int key, UserClaim userClaim) { if (!ModelState.IsValid) { return BadRequest(ModelState); } if (key != userClaim.Id) { return BadRequest(); } try { await MainUnitOfWork.UpdateAsync(userClaim); } catch (DbUpdateConcurrencyException) { if (!MainUnitOfWork.Exists(key)) { return NotFound(); } else { return Conflict(); } } return Ok(userClaim); }
protected override void AddClaim(UserClaim item) { var claim = new NhUserClaim(); claim.GetType().GetProperty("Type").SetValue(claim, item.Type); claim.GetType().GetProperty("Value").SetValue(claim, item.Value); claim.GetType().GetProperty("Account").SetValue(claim, this); this.ClaimsCollection.Add(claim); }
public void Ctor_InitializesNothing() { var entity = new UserClaim(); entity.Id.ShouldEqual(0); entity.User.ShouldBeNull(); entity.UserId.ShouldEqual(0); entity.ClaimType.ShouldBeNull(); entity.ClaimValue.ShouldBeNull(); }
public static UserClaim FromIUserClaim(IUserClaim i) { UserClaim u = new UserClaim(); u.ClaimType = i.ClaimType; u.ClaimValue = i.ClaimValue; u.Id = i.Id; u.SiteId = i.SiteId; u.UserId = i.UserId; return u; }
public int ReplaceClaim(User user, UserClaim claim, UserClaim newClaim) { return(BusinessEngine.ReplaceClaim(user, claim, newClaim)); }
protected internal void AddClaim(UserClaim item) => this.ClaimCollection.Add(item);
private async Task <bool> DoesClaimExistsForUser(UserClaim userClaim) { return((await _userClaimsRepository.GetAsync(x => x.UserId == userClaim.UserId && x.ClaimId == userClaim.ClaimId)) is { });
private void SeedUsers(LegatoContext context) { var addGuitar = new UserClaim { ClaimName = Constants.Constants.AddGuitarClaim }; var removeGuitar = new UserClaim { ClaimName = Constants.Constants.RemoveGuitarClaim }; var editGuitar = new UserClaim { ClaimName = Constants.Constants.EditGuitarClaim }; var changeDisplayAmount = new UserClaim { ClaimName = Constants.Constants.ChangeDisplayAmountClaim }; var blockUser = new UserClaim { ClaimName = Constants.Constants.BlockUserClaim }; var getListOfUsers = new UserClaim { ClaimName = Constants.Constants.GetListOfUsersClaim }; var getCompromisedAttempts = new UserClaim { ClaimName = Constants.Constants.GetCompromisedAttemptsClaim }; var removeCompromisedAttempts = new UserClaim { ClaimName = Constants.Constants.RemoveCompromisedAttemptsClaim }; var user = new UserRole { RoleName = "User", UserClaims = new List <UserClaim>() }; var admin = new UserRole { RoleName = "Admin", UserClaims = new List <UserClaim> { addGuitar, removeGuitar, editGuitar, blockUser } }; var superuser = new UserRole { RoleName = "Superuser", UserClaims = new List <UserClaim> { addGuitar, removeGuitar, editGuitar, blockUser, changeDisplayAmount, getListOfUsers, getCompromisedAttempts, removeCompromisedAttempts } }; context.UserClaims.Add(addGuitar); context.UserClaims.Add(removeGuitar); context.UserClaims.Add(editGuitar); context.UserClaims.Add(changeDisplayAmount); context.UserClaims.Add(blockUser); context.UserClaims.Add(getListOfUsers); context.UserClaims.Add(getCompromisedAttempts); context.UserClaims.Add(removeCompromisedAttempts); context.UserRoles.Add(user); context.UserRoles.Add(admin); context.UserRoles.Add(superuser); string adminPassword = Hashing.HashData("admin"); string superuserPassword = Hashing.HashData("superuser"); string userPassword = Hashing.HashData("user"); context.Users.Add(new UserModel { Username = "******", EncryptedPassword = adminPassword, IsAuthenticated = false, UserRole = admin }); context.Users.Add(new UserModel { Username = "******", EncryptedPassword = superuserPassword, IsAuthenticated = false, UserRole = superuser }); context.Users.Add(new UserModel { Username = "******", EncryptedPassword = userPassword, IsAuthenticated = false, UserRole = user }); // seeding fake user data for (int i = 0; i < 100; i++) { string password = Hashing.HashData("qwerty"); context.Users.Add(new UserModel { Username = Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 8), EncryptedPassword = password, IsAuthenticated = false, UserRole = user }); } }
protected internal override void AddClaim(UserClaim item) { ClaimCollection.Add(new RelationalUserClaim { UserAccountID = this.ID, Type = item.Type, Value = item.Value }); }
protected internal override void RemoveClaim(UserClaim item) { ClaimCollection.Remove(item); }
public ActionResult RSVP() { var vm = new RsvpViewModel(); var identity = Thread.CurrentPrincipal as ClaimsPrincipal; string guestCode = null; GuestCode dbCode = null; using (var db = new WeddingManagementContext()) { if (identity.HasClaim(c => c.Type == "GuestCode")) { guestCode = identity.FindFirst("GuestCode").Value.ToUpper(); dbCode = db.GuestCodes.FirstOrDefault(gc => gc.GuestCode1.ToUpper() == guestCode); } else { int userId = User.Identity.GetUserId <int>(); UserClaim guestCodeClaim = db.Users.FirstOrDefault(u => u.Id == userId).Claims.FirstOrDefault(c => c.ClaimType == "GuestCode"); if (guestCodeClaim != null) { dbCode = db.GuestCodes.FirstOrDefault(gc => gc.GuestCode1.ToUpper() == guestCodeClaim.ClaimValue.ToUpper()); } } if (dbCode != null) { vm.GuestCode = dbCode.GuestCode1; if (dbCode.GuestId != null) { Guest dbGuest = db.Guests.FirstOrDefault(g => g.GuestId == dbCode.GuestId); if (dbGuest != null) { vm.Name = dbGuest.Name; vm.AllowedGuests = dbGuest.MaxAllowed; if (dbGuest.RSVPFlag) { vm.Attending = dbGuest.NumberAttending >= 0; } if (dbGuest.NumberAttending >= 0) { vm.NumberOfGuests = dbGuest.NumberAttending; } } } else { // TODO: Consider redirecting to register guest if the code isn't attached to a guest. } } } return(View(vm)); }
/// TODO: look at combining with the UserRegisteredHandler /// <summary> /// Automatically provisions a user. /// </summary> /// <param name="provider">The provider.</param> /// <param name="userId">The user identifier.</param> /// <param name="claims">The claims.</param> /// <returns></returns> public User AutoProvisionUser(string provider, string userId, List <Claim> claims) { // create a list of claims that we want to transfer into our store var filtered = new List <Claim>(); foreach (var claim in claims) { // if the external system sends a display name - translate that to the standard OIDC name claim if (claim.Type == ClaimTypes.Name) { filtered.Add(new Claim(JwtClaimTypes.Name, claim.Value)); } // if the JWT handler has an outbound mapping to an OIDC claim use that else if (JwtSecurityTokenHandler.DefaultOutboundClaimTypeMap.ContainsKey(claim.Type)) { filtered.Add(new Claim(JwtSecurityTokenHandler.DefaultOutboundClaimTypeMap[claim.Type], claim.Value)); } // copy the claim as-is else { filtered.Add(claim); } } // if no display name was provided, try to construct by first and/or last name if (!filtered.Any(x => x.Type == JwtClaimTypes.Name)) { var first = filtered.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value; var last = filtered.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value; if (first != null && last != null) { filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last)); } else if (first != null) { filtered.Add(new Claim(JwtClaimTypes.Name, first)); } else if (last != null) { filtered.Add(new Claim(JwtClaimTypes.Name, last)); } } // create a new unique subject id var sub = Guid.NewGuid(); // check if a 'upn' (User Principal Name) claim is available otherwise check if display name is available, otherwise fallback to subject id var name = filtered.FirstOrDefault(c => c.Type == "upn")?.Value ?? filtered.FirstOrDefault(c => c.Type == JwtClaimTypes.Name)?.Value ?? sub.ToString(); // create new user var user = new User { UserId = sub, Username = name, ProviderName = provider, ProviderSubjectId = userId, // set to someting since values are required (TODO?) Password = "******", Salt = "", EffectiveDate = DateTime.UtcNow, UserStatus = "Active", TermsOfUseAcceptanceDate = DateTime.UtcNow, CreateDate = DateTime.UtcNow, LastModifiedDate = DateTime.UtcNow }; logger.LogInformation($"About to create new user: {name}"); using (var ctx = contextFactory.NewUserDbContext()) { //Probably not a great way of doing this, need a user for audit fields. var theFirstUser = ctx.Users.OrderBy(x => x.UserId).First(); user.CreateUserId = theFirstUser.UserId; user.LastModifiedUserId = theFirstUser.UserId; /* * // TODO: get role(s) from groups * var roleName = "customer"; * var role = ctx.Roles.FirstOrDefault(r => r.Name == roleName); * * if (role == null) { * role = new Role { * Name = roleName, * Description = roleName, * CreateDate = DateTime.UtcNow, * LastModifiedDate = DateTime.UtcNow, * CreateUserId = theFirstUser.UserId, * LastModifiedUserId = theFirstUser.UserId * }; * ctx.AddRole(role); * } * * user.UserRoles = new List<UserRole> { * new UserRole { * User = user, * Role = role * } * }; */ user.UserClaims = new List <UserClaim>(); foreach (var c in filtered) { var claim = new UserClaim() { UserId = user.UserId, ProviderName = provider, Type = c.Type, Value = c.Value }; user.UserClaims.Add(claim); } ctx.AddUser(user); ctx.SaveChanges(); } return(user); }
public OperationResult <UserClaim> ChangeUserClaim(int id, [FromBody] UserClaim obj) => Controller.ChangeUserClaim(obj);
//[ValidationAspect(typeof(UserClaimValidator))] public IResult Update(UserClaim entity) { _userDal.Update(entity); return(new SuccessResult(Messages.ItemUpdated)); }
protected override void RemoveClaim(UserClaim item) { var removed = this.ClaimsCollection.SingleOrDefault(x => x.Type == item.Type && x.Value == item.Value); this.ClaimsCollection.Remove(removed); }
public bool Delete(UserClaim userClaim) { return(this.Database.Delete <UserClaim>(userClaim)); }
public async Task <bool> InsertAsync(UserClaim userClaim) { var result = await this.Database.InsertAsync <UserClaim>(userClaim); return(result); }
public object GetByLogin(CredenciaisAcesso credenciais) { bool credentialsIsValid = false; if (credenciais != null && !string.IsNullOrWhiteSpace(credenciais.Usuario)) { baseUser = _userRepository.GetByLogin(credenciais.Usuario); if (credenciais.TipoConcessao == "password") { //converte em base64 var plainTextBytes = Encoding.UTF8.GetBytes(credenciais.Senha); string encodedText = Convert.ToBase64String(plainTextBytes); credenciais.Senha = encodedText; credentialsIsValid = (baseUser != null && credenciais.Usuario == baseUser.Email && credenciais.Senha == baseUser.Senha); } else if (credenciais.TipoConcessao == "refresh_token") { if (!String.IsNullOrWhiteSpace(credenciais.RefreshToken)) { RefreshToken refreshTokenBase = _refreshTokenRepository.GetRefreshToken(baseUser.PessoaId); DateTime expirationDate = DateTime.Parse(credenciais.Expiration); expirationDate = expirationDate + TimeSpan.FromSeconds(_tokenConfiguration.FinalExpiration); DateTime atual = DateTime.Now; credentialsIsValid = (refreshTokenBase != null && baseUser.PessoaId == refreshTokenBase.PessoaId && refreshTokenBase.Token == credenciais.RefreshToken && expirationDate >= atual); } } } if (credentialsIsValid) { var userClaim = UserClaim.ConvertEntityToClaim(baseUser); var identity = new ClaimsIdentity( new GenericIdentity(userClaim.Email, "Email"), new[] { new Claim(ClaimTypes.Sid, userClaim.PessoaId.ToString()), new Claim(ClaimTypes.Name, baseUser.Nome), new Claim(ClaimTypes.Email, userClaim.Email), new Claim(ClaimTypes.NameIdentifier, userClaim.PessoaId.ToString()) } ); DateTime createDate = DateTime.Now.ToUniversalTime(); DateTime expirationDate = createDate.ToUniversalTime() + TimeSpan.FromSeconds(_tokenConfiguration.Seconds); // Calcula o tempo máximo de validade do refresh token // (o mesmo será invalidado automaticamente pelo Redis) TimeSpan finalExpiration = TimeSpan.FromSeconds(_tokenConfiguration.FinalExpiration); var handler = new JwtSecurityTokenHandler(); string token = CreateToken(identity, createDate, expirationDate, handler); return(SuccessObject(createDate, expirationDate, token, finalExpiration, baseUser.PessoaId)); } else { return(ExceptionObject()); } }
public string Encode(UserClaim userClaim) { var defaultExpMinutes = new TimeSpan(0, 20, 0).TotalMinutes; return(Encode(userClaim, defaultExpMinutes)); }
public async Task <string> ExecuteAsync(UserClaim userClaim) { return(await Task.FromResult(this.jwtFactory.Create(userClaim))); }
// POST odata/UserClaim public virtual async Task<IHttpActionResult> Post(UserClaim userClaim) { if (!ModelState.IsValid) { return BadRequest(ModelState); } try { await MainUnitOfWork.InsertAsync(userClaim); } catch (DbUpdateException) { if (MainUnitOfWork.Exists(userClaim.Id)) { return Conflict(); } else { throw; } } return Created(userClaim); }
public void RemoveUserClaim(UserClaim userClaim) { var claim = mapper.Map <UserClaim, IdentityUserClaim <string> >(userClaim); repositoryOfUserClaim.Delete(claim); }
public void Add(UserClaim entity) { Context.Set <UserClaim>().Add(entity); }
public void OnActionExecuting(ActionExecutingContext context) { var response = new ApiResponseModel(); var validations = new List <Validation>(); var AuthToken = (context.HttpContext.Request.Headers.TryGetValue("AuthToken", out var authorizationToken)) ? authorizationToken.ToString() : string.Empty; var ip = context.HttpContext.Connection.RemoteIpAddress; var auditLoginRepo = new AuditLoginRepository(_uow); var currentData = new AuditLogin(); try { if (string.IsNullOrEmpty(AuthToken)) { validations.Add(new Validation() { Key = "Token", Value = "Please send your Token to Access this resource" }); } else { var val = AuthToken.Split("."); if (val.Length != int.Parse(_uow.GetAppSettings("SecuredTokenLength"))) { validations.Add(new Validation() { Key = "Token", Value = "Incorrect Token Format" }); } else { var UserClaim = Helper.Decrypt(val[0], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize"))); var UserToken = Helper.Decrypt(val[1], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize"))); var IpAddress = Helper.Decrypt(val[2], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize")));; var ExecutedDate = Helper.Decrypt(val[3], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize")));; UserClaim UserClaimResult = Helper.JSONDeserialize <UserClaim>(UserClaim); _uow.OpenConnection("dbConnection"); currentData = auditLoginRepo.ReadByLambda(x => x.UserID == UserClaimResult.UserID).FirstOrDefault(); if (currentData == null) { validations.Add(new Validation() { Key = "User", Value = "We couldnt find your user id" }); } else { if (currentData.UserKey != UserToken) { validations.Add(new Validation() { Key = "User", Value = "Incorrect User Token" }); } else { if (currentData.IPAddress != IpAddress) { validations.Add(new Validation() { Key = "User", Value = "Oooppsss another user use your user id" }); } else { if (currentData.IPAddress != ip.ToString()) { validations.Add(new Validation() { Key = "User", Value = "Oooppsss there is someone on middle" }); } else { ////7GgDQjrzTdLDVkw/2q6U3xYt3Kk7pKtWp1WHyMHhE3s= --> 2020-05-22 13:35:53 var date = DateTime.Parse(ExecutedDate); } } } } } } response.Validations = validations; if (response.Validations.Count > 0) { context.HttpContext.Response.StatusCode = (int)ResponseMessageEnum.UnAuthorized; context.Result = ApiHelper.Response(ResponseMessageEnum.UnAuthorized, response); } } catch { context.Result = ApiHelper.Response(ResponseMessageEnum.InternalServerError, response); } }
public async Task AddUserClaimAsync(UserClaim userClaim) { _wpbDataContext.UserClaims.Add(userClaim); await _wpbDataContext.SaveChangesAsync(); }
public bool MockDataCreator() { // Note By Fernando: This is a small "hack" to avoid the system to be initialized without Test-Data (FakeData). I've created this method to // Feed data and fill database with some tests info, that will display a better and most complete panel with some Manufacturers, Models... // You can skip the call of this method by commenting the line on UserHandler > Handle(CreateUser) var usersOnDb = GetUsers().ToList(); //will check if database is empty (no one user exists - first user) before run if (usersOnDb.Count == 0) { var users = new User[] { new User("Created by loadFakeData", new Name("Admin", "SystemAdmin"), new Document("33557788-9", "55448899"), new Phone("3699955566", "", "", ""), new Email("*****@*****.**"), new Address("Street Api", "12", "Solid Village", "City of NetCore", "7788"), new UserAccount("admin", "admin") ) }; _context.Users.AddRange(users); _context.SaveChanges(); //I'm calling SaveChanges each time because i need DB to generate the Guids then it will be stored here to the Fks var manufacturers = new Manufacturer[] { new Manufacturer("Xiaomi"), new Manufacturer("Motorola"), new Manufacturer("Samsung"), new Manufacturer("LG") }; _context.Manufacturers.AddRange(manufacturers); _context.SaveChanges(); var deviceModels = new DeviceModel[] { new DeviceModel("Mi Max 2", manufacturers[0]), //0 new DeviceModel("Redmi Note 10", manufacturers[0]), //1 new DeviceModel("Moto G8", manufacturers[1]), //2 new DeviceModel("Galaxy S20 Plus", manufacturers[2]), //3 new DeviceModel("Galaxy S10e", manufacturers[2]), //4 new DeviceModel("LG V60", manufacturers[3]), //5 }; _context.DeviceModels.AddRange(deviceModels); _context.SaveChanges(); var claims = new Claim[] { new Claim("dashboard", ""), new Claim("manufacturer", ""), new Claim("devicemodel", ""), new Claim("user", ""), new Claim("equipment", ""), }; _context.Claims.AddRange(claims); _context.SaveChanges(); var userClaims = new UserClaim[] { new UserClaim(users[0], claims[0]), new UserClaim(users[0], claims[1]), new UserClaim(users[0], claims[2]), new UserClaim(users[0], claims[3]), new UserClaim(users[0], claims[4]), }; _context.UserClaims.AddRange(userClaims); _context.SaveChanges(); var equipments = new Equipment[] { new Equipment("8c4997076d138ae6", "864166044650604", "864167058640512", "36-555-777", "EC:D0:8F:2F:09:D5", "25", "Android 7.1", "5588997788234", "Android", "7.1.1", deviceModels[0], users[0]), //mimax2 new Equipment("8c4997076d138bc6", "864166044650605", "864167058640513", "36-555-778", "EC:D0:8F:2F:09:D1", "25", "Android 7.1", "5588997788231", "Android", "7.1.1", deviceModels[1], users[0]), //note10 new Equipment("8c4997076d138bd6", "864166044650655", "864167058640556", "36-555-790", "EC:D0:8F:2F:09:D6", "27", "Android 8.1", "5588997788333", "Android", "8.1", deviceModels[1], users[0]), //note10 new Equipment("8c4997076d138ae7", "864166044650603", "864167058640514", "36-555-779", "EC:D0:8F:2F:09:D7", "27", "Android 8.1", "5588997788232", "Android", "8.1", deviceModels[2], users[0]), //g8 new Equipment("8c4997076d138cc7", "864166044650601", "864167058640517", "36-555-780", "EC:D0:8F:2F:09:D2", "27", "Android 8.1", "5588997788235", "Android", "8.1", deviceModels[3], users[0]), //s20 new Equipment("8c4997076d138dc7", "864166044650608", "864167058640518", "36-555-781", "EC:D0:8F:2F:09:D3", "27", "Android 8.1", "5588997788236", "Android", "8.1", deviceModels[4], users[0]), //ss10e new Equipment("8c4997076d138cc7", "864166044650602", "864167058640519", "36-555-784", "EC:D0:8F:2F:09:D8", "28", "Android 9", "5588997788245", "Android", "9", deviceModels[5], users[0]), //v60 }; _context.Equipments.AddRange(equipments); _context.SaveChanges(); } return(true); }
private void OnDeleteClaimClicked(UserClaim claim) { Collection.Remove(claim); HandleModificationState.EntityDeleted(claim); }
public OperationResult <UserClaim> AddClaim(int id, [FromBody] UserClaim obj) { obj.UserId = id; return(Controller.AddUserClaim(obj)); }
protected internal void RemoveClaim(UserClaim item) => this.ClaimCollection.Remove(item);
public UserClaim ChangeUserClaim(UserClaim obj) { return(Run(() => Change(obj))); }
public IList <User> GetUsersForClaim(UserClaim claim) { return(BusinessEngine.GetUsersForClaim(claim)); }
public UserClaim AddUserClaim(UserClaim obj) { return(Run(() => Add(obj), saveChanges: true)); }
public bool Insert(UserClaim userClaim) { return(this.Database.Insert <UserClaim>(userClaim)); }
public bool HasClaim(UserClaim claim) { return(UserModel.Claims.Contains(claim)); }
public async Task InitializeTenant(DbContext context, Tenant tenant, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); var found = await context.Set <Tenant>() .Where(e => e.Name == tenant.Name && e.HostName == e.HostName) .FirstOrDefaultAsync(cancellationToken); if (found == null) { await context.Set <Tenant>().AddAsync(tenant, cancellationToken); //await context.SaveChangesAsync(); } var foundId = found != null ? found.Id : tenant.Id; var foundName = found != null ? found.Name : tenant.Name; var hasCompany = await context.Set <Company>() .AnyAsync(c => c.TenantId == foundId && c.Code == foundName, cancellationToken); if (!hasCompany) { var company = new Company { Code = tenant.Name, Name = tenant.Name, Tenant = found != null ? found : tenant, DateCreated = DateTime.UtcNow }; await context.Set <Company>().AddAsync(company, cancellationToken); //await context.SaveChangesAsync(); var passwordHasher = new PasswordHasher <User>(); var user = new User { Company = company, Tenant = tenant, Active = true, IsSystemAdministrator = true, UserName = "******", NormalizedUserName = "******", Password = "******", NormalizedEmail = "*****@*****.**", Email = "*****@*****.**", RecoveryEmail = "*****@*****.**", Deleted = false, DateCreated = DateTime.UtcNow, EmailConfirmed = true, IsConfirmed = true, SecurityStamp = Guid.NewGuid().ToString() }; user.PasswordHash = passwordHasher.HashPassword(user, "12345678"); await context.Set <User>().AddAsync(user, cancellationToken); var role = new Role() { Active = true, Name = "Superuser", NormalizedName = "SUPERUSER", Company = company, Tenant = company.Tenant }; await context.Set <Role>().AddAsync(role, cancellationToken); var claim = new Claim(CompanyClaimTypes.Role, role.Name); var userClaim = new UserClaim { ClaimType = claim.Type, ClaimValue = claim.Value, User = user }; await context.Set <UserClaim>().AddAsync(userClaim, cancellationToken); var userRole = new UserRole { Role = role, User = user }; await context.Set <UserRole>().AddAsync(userRole, cancellationToken); } if (context.ChangeTracker.HasChanges()) { await context.SaveChangesAsync(cancellationToken); } }
/// <summary> /// Adds to or updates a <see cref="UserClaim"/> in a target <see cref="CategoryPolicy"/> object. /// </summary> /// <param name="categoryPolicy">The target <see cref="CategoryPolicy"/> object where the <see cref="UserClaim"/> needs to be updated or added into.</param> /// <param name="policies">The list of <see cref="CategoryPolicy"/> where the target <see cref="CategoryPolicy"/> object is contained.</param> /// <returns>The updated list of <see cref="SampleQueriesPolicies"/> /// with the new <see cref="UserClaim"/> added or updated at the target <see cref="CategoryPolicy"/> object.</returns> public static SampleQueriesPolicies ModifyUserClaim(SampleQueriesPolicies policies, CategoryPolicy categoryPolicy) { if (policies == null || policies.CategoryPolicies.Count == 0) { throw new ArgumentNullException(nameof(SampleQueriesPolicies), "The list of policies cannot be null or empty."); } if (categoryPolicy == null) { throw new ArgumentNullException(nameof(CategoryPolicy), "The category policy cannot be null."); } // Search the target category policy from the list of policies CategoryPolicy tempCategoryPolicy = policies.CategoryPolicies.Find(x => x.CategoryName == categoryPolicy.CategoryName); if (tempCategoryPolicy == null) { throw new InvalidOperationException($"The specified category policy doesn't exist: {categoryPolicy.CategoryName}"); } // This will be used later to insert the updated category policy back into the list of policies int tempCategoryPolicyIndex = policies.CategoryPolicies.FindIndex(x => x == tempCategoryPolicy); // Fetch the first user claim from the argument supplied UserClaim userClaim = categoryPolicy.UserClaims.FirstOrDefault(); if (userClaim == null) { throw new ArgumentNullException(nameof(CategoryPolicy), "User claim information missing."); } // Get the location of the provided user claim from the temp. category policy int userClaimIndex = tempCategoryPolicy.UserClaims.FindIndex(x => x.UserPrincipalName == userClaim.UserPrincipalName); // Add new user claim request if (userClaimIndex < 0) { // Check first whether we have default user claim values in the temp. category policy CategoryPolicy defaultCategoryPolicyTemplate = new CategoryPolicy { UserClaims = new List <UserClaim>() { new UserClaim() } }; if (tempCategoryPolicy.UserClaims.First().UserPrincipalName == defaultCategoryPolicyTemplate.UserClaims.First().UserPrincipalName) { /* This is the first claim for this category policy; * clear the default user claim and add the new user claim. */ tempCategoryPolicy.UserClaims.Clear(); tempCategoryPolicy.UserClaims.Add(userClaim); } else // we already have other unique user claim values in this category policy { // Insert the new user claim info. to the end of list of user claims tempCategoryPolicy.UserClaims.Add(userClaim); } } else // Update user claim request { // Update the current index with new user claim info. tempCategoryPolicy.UserClaims.Insert(userClaimIndex, userClaim); // Delete the original user claim pushed to the next index tempCategoryPolicy.UserClaims.RemoveAt(++userClaimIndex); } // Update the modified category policy back into list of policies policies.CategoryPolicies.Insert(tempCategoryPolicyIndex, tempCategoryPolicy); // Delete the original category policy pushed to the next index policies.CategoryPolicies.RemoveAt(++tempCategoryPolicyIndex); return(policies); }
protected internal override void AddClaim(UserClaim item) { base.AddClaim(item); }
public async Task <IActionResult> ManageUserClaims(string userId, int projectId) { Global.ProjectId = projectId; var project = _projectRepository.GetProject(projectId); Global.Project = project; var uId = userManager.GetUserId(User); var currentUser = await userManager.FindByIdAsync(uId); var uClaims = await userManager.GetClaimsAsync(currentUser); Global.globalCurrentUserClaims = uClaims.ToList(); var user = await userManager.FindByIdAsync(userId); var IsManagerLevel = ClaimsLevel.IsManager(User.Claims.ToList(), projectId); if (IsManagerLevel == false) { return(RedirectToAction("AccessDenied", "Account")); } else if (userId == userManager.GetUserId(User) || userId == project.OwnerId) { return(RedirectToAction("AccessDenied", "Account")); } if (user == null) { ViewBag.ErrorMessage = $"User with id {userId} doesn't exist"; return(View("NotFound")); } var existingUserClaims = await userManager.GetClaimsAsync(user); //foreach(var claim in existingUserClaims) //{ // Console.WriteLine("------"); // Console.WriteLine(claim.Type); // Console.WriteLine(claim.Value); //} var viewModel = new ClaimsViewModel { UserId = userId, ProjectId = projectId }; for (var i = 0; i < ClaimsPile.AllClaims.Count; i++) { UserClaim userClaim = new UserClaim { ClaimType = ClaimsPile.AllClaims[i].Type }; var projectList = new List <string>(); if (existingUserClaims.Count == 4) { projectList = existingUserClaims[i].Value.Split(" ").ToList(); } for (int j = 0; j < projectList.Count; j++) { if (projectList[j] == projectId.ToString()) { userClaim.IsSelected = true; break; } } viewModel.Claims.Add(userClaim); } foreach (var claim in viewModel.Claims) { Console.WriteLine(claim.ClaimType); Console.WriteLine(claim.IsSelected); } return(View(viewModel)); }
protected internal override void AddClaim(UserClaim item) { ClaimCollection.Add(item); }
public async Task OnPostAsync() { // Arrange const string originalUserClaim2Type = "Claim 2 Type"; const string newUserClaim2Type = "New Claim Type"; var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}"; var options = new DbContextOptionsBuilder <IdentityServerDbContext>() .UseInMemoryDatabase(databaseName) .Options; var userClaim1 = new UserClaim { ClaimType = "Claim 1 Type", ClaimValue = "Claim 1 Value" }; var userClaim2 = new UserClaim { ClaimType = originalUserClaim2Type, ClaimValue = "Claim 2 Value" }; var userClaim3 = new UserClaim { ClaimType = "Claim 3 Type", ClaimValue = "Claim 3 Value" }; var userClaim4 = new UserClaim { ClaimType = "Claim 4 Type", ClaimValue = "Claim 4 Value" }; var user = new User { Email = "Email" }; user.Claims.Add(userClaim1); user.Claims.Add(userClaim2); user.Claims.Add(userClaim3); using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object)) { context.Add(user); await context.SaveChangesAsync().ConfigureAwait(false); } IActionResult post; // Act using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object)) { _userManager.Setup(x => x.Users).Returns(context.Users); var model = new ClaimsModel(_userManager.Object) { UserModel = user }; model.UserModel.Claims.Single(x => x.ClaimType.Equals(userClaim2.ClaimType)).ClaimType = newUserClaim2Type; model.UserModel.Claims.Remove(userClaim3); model.UserModel.Claims.Add(userClaim4); post = await model.OnPostAsync().ConfigureAwait(false); } // Assert _userManager.Verify(x => x.ReplaceClaimAsync( It.Is <User>(y => y.Id.Equals(user.Id)), It.Is <Claim>(y => y.Type.Equals(userClaim1.ClaimType) && y.Value.Equals(userClaim1.ClaimValue)), It.IsAny <Claim>()), Times.Never); _userManager.Verify(x => x.ReplaceClaimAsync( It.Is <User>(y => y.Id.Equals(user.Id)), It.Is <Claim>(y => y.Type.Equals(originalUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue)), It.Is <Claim>(y => y.Type.Equals(newUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue))), Times.Once); _userManager.Verify( x => x.AddClaimsAsync( It.Is <User>(y => y.Id.Equals(user.Id)), It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim4.ClaimType) && z.Value.Equals(userClaim4.ClaimValue)) != null)), Times.Once); _userManager.Verify( x => x.RemoveClaimsAsync( It.Is <User>(y => y.Id.Equals(user.Id)), It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim3.ClaimType) && z.Value.Equals(userClaim3.ClaimValue)) != null)), Times.Once); var result = Assert.IsType <RedirectToPageResult>(post); Assert.Equal("../Details/Claims", result.PageName); Assert.Collection(result.RouteValues, routeValue => { var(key, value) = routeValue; Assert.Equal(nameof(User.Id), key); Assert.Equal(user.Id, value); }); }
protected internal override void AddClaim(UserClaim item) { ClaimCollection.Add(new RelationalUserClaimInt { UserAccountID = this.Key, Type = item.Type, Value = item.Value }); }
protected internal override void RemoveClaim(UserClaim item) { ClaimCollection.Remove((RelationalUserClaimInt)item); }