public Task AddClaimsAsync(ApplicationUser user, IEnumerable <Claim> claims, CancellationToken cancellationToken) { ThrowIfDisposed(); if (user == null) { throw new ArgumentNullException(nameof(user)); } if (claims == null) { throw new ArgumentNullException(nameof(claims)); } foreach (var claim in claims) { UserClaims.Add(CreateUserClaim(user, claim)); } return(Task.FromResult(false)); }
public void Should_FailValidation_When_ClaimsIsNull() { // Arrange var claimsValidator = new ClaimsValidator(); var claims = new UserClaims() { Claims = null }; // Act var result = claimsValidator.Validate(claims); var isValid = result.IsValid; // Assert isValid.Should().Be(false); }
public void Should_PassValidation_When_AllRulesPass() { // Arrange var claimsValidator = new ClaimsValidator(); var claimsFactory = new ClaimsFactory(); var claims = new UserClaims() { Claims = claimsFactory.Create(AccountTypes.Individual) }; // Act var result = claimsValidator.Validate(claims); var isValid = result.IsValid; // Assert isValid.Should().Be(true); }
public ApiScope ToEntity(IdentityServer4.EntityFramework.Entities.ApiResource savedApi) { return(new ApiScope() { ApiResourceId = savedApi.Id, Description = Description, Required = Required, DisplayName = DisplayName, Emphasize = Emphasize, Name = Name, ShowInDiscoveryDocument = ShowInDiscoveryDocument, UserClaims = UserClaims.Select(s => new ApiScopeClaim() { Type = s }).ToList(), }); }
//[TestCase(TestName = "When the userorganisations controller CreateUserOrganisation action is called and the UserOrganisationsUseCase gets created it returns a response with a status code")] public void ReturnsResponseWithStatus() { UserClaims userClaims = new UserClaims { UserId = 1, UserRole = "Admin" }; var expected = Randomm.Create <UserOrganisationResponse>(); var requestParams = Randomm.Create <UserOrganisationRequest>(); _mockUseCase.Setup(u => u.ExecuteCreate(requestParams, userClaims)).Returns(expected); var response = _classUnderTest.CreateUserOrganisation(requestParams) as CreatedResult; response.Should().NotBeNull(); response.StatusCode.Should().Be(201); response.Value.Should().BeEquivalentTo(expected); }
public IActionResult CreateUserOrganisation(UserOrganisationRequest requestParams) { try { UserClaims userClaims = new UserClaims { UserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value), UserRole = HttpContext.User.FindFirst(ClaimTypes.Role).Value }; LambdaLogger.Log($"UserID:{userClaims.UserId.ToString()} UserRole:{userClaims.UserRole}"); if (string.IsNullOrEmpty(AccessToken)) { return(BadRequest("no access_token cookie found in the request")); } var response = _userOrganisationLinksUseCase.ExecuteCreate(requestParams, userClaims); if (response != null) { return(Created(new Uri($"/{response.Id}", UriKind.Relative), response)); } } catch (InvalidOperationException e) { LoggingHandler.LogError(e.Message); LoggingHandler.LogError(e.StackTrace); return(BadRequest( new ErrorResponse($"Error creating userorganisation") { Status = "Bad request", Errors = new List <string> { $"An error occurred attempting to create userorganisation with userId {requestParams.UserId} and organisationId {requestParams.OrganisationId}: {e.Message}" } })); } catch (UseCaseException e) { return(BadRequest(e)); } return(BadRequest( new ErrorResponse($"Invalid request. ") { Status = "Bad request", Errors = new List <string> { "Unable to create organisation." } })); }
public async Task <IActionResult> UpdateTodoStatus(UpdateTodoStatus obj) { try { if (ModelState.IsValid) { ClaimsIdentity claimsIdentity = User.Identity as ClaimsIdentity; var currentLoginUserid = new UserClaims(claimsIdentity).LoggedInUserId; var currentLoginUserOrgid = new UserClaims(claimsIdentity).OrgId; obj.updateBy = currentLoginUserid; using (var uow = new UnitOfWork(_configs.Value.DbConnectionString)) { await uow.AdvanceLeadCreator.UpdateTodoStatusAsync(obj.todoId, obj.updateFlag, obj.status, obj.updateBy); uow.Commit(); if (obj.updateFlag == 0) { return(Ok(new ApiResponse { message = ApiMessageConstants.commonDeleted })); } else { return(Ok(new ApiResponse { message = ApiMessageConstants.commonUpdated })); } } } else { return(BadRequest(new ApiResponse { message = ApiMessageConstants.someThingWentWrong })); } } catch (Exception ex) { return(BadRequest(new ApiResponse { message = ex.Message })); } }
public virtual async Task <ClaimsPrincipal> Authenticate() { var principal = await this.Authenticate(this._options.AuthenticationScheme) .ConfigureAwait(false); if (principal == null) { return(null); } var claims = new UserClaims(principal.Identities.Where( i => i.AuthenticationType == this._options.AuthenticationScheme).Single(), this._options.ClaimTypes); if (!claims.IsValid) { await this.Logout().ConfigureAwait(false); return(null); } var timeSinceCheck = this._clock.UtcNow - claims.SecurityStampValidated; if (timeSinceCheck < this._options.ValidateSecurityStampInterval) { return(principal); } var user = await this._store.Retrieve(claims.UserKey).ConfigureAwait(false); if (user?.SecurityStamp == claims.SecurityStamp) { principal = this.UpdateSecurityStampValidatedClaim(principal); await this.RefreshLogin(principal).ConfigureAwait(false); return(principal); } else { await this.Logout().ConfigureAwait(false); return(null); } }
public ApiResource(string scopeName, string displayName, IEnumerable <string> userClaimTypes) { if (scopeName.IsMissing()) { throw new ArgumentNullException(nameof(scopeName)); } Name = scopeName; Scopes.Add(new Scope(scopeName, displayName)); if (!userClaimTypes.IsNullOrEmpty()) { foreach (var type in userClaimTypes) { UserClaims.Add(new UserClaim(type)); } } }
//[Property(DisplayName = "Submitting default FollowDeckCommand _ displays validation error", Arbitrary = new[] { typeof(FollowButtonTestsArb) })] public bool _1(UserClaims userClaims, DeckWithFollowMeta deckWithFollowMeta, DeckEntity usersDefaultDeck) { Setup(Services, db => new UserEntity { Id = userClaims.Id, DefaultDeckId = usersDefaultDeck.Id, Decks = new List <DeckEntity> { usersDefaultDeck } }.Pipe(db.User.Add)); var counter = RenderComponent <FollowButtons>( (nameof(FollowButtons.Deck), deckWithFollowMeta), CascadingValue(Task.FromResult(userClaims)) ); counter.Find("form").Submit(); return("'New Deck Name' must not be empty." == counter.Find(".validation-message").TextContent); }
public async Task <IActionResult> GetApplicationUsersWithClaimsAsync() { List <ApplicationUser> applicationUserList = userManager.Users.ToList(); List <UserClaims> userClaimsList = new List <UserClaims>(); foreach (ApplicationUser user in applicationUserList) { var newUserClaim = new UserClaims(); newUserClaim.ApplicationUser = user; newUserClaim.IdentityUserClaim = await userManager.GetClaimsAsync(user); userClaimsList.Add(newUserClaim); } return(Ok(userClaimsList)); }
/// <inheritdoc /> public override async Task ReplaceClaimAsync(TUser user, Claim claim, Claim newClaim, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); user.ThrowIfNull(nameof(user)); claim.ThrowIfNull(nameof(claim)); newClaim.ThrowIfNull(nameof(newClaim)); UserClaims ??= (await UserClaimsRecord.GetClaimsAsync(user.Id)).ToList(); var matchedClaims = UserClaims.Where(x => x.UserId.Equals(user.Id) && x.ClaimType == claim.Type && x.ClaimValue == claim.Value); foreach (var matchedClaim in matchedClaims) { matchedClaim.ClaimValue = newClaim.Value; matchedClaim.ClaimType = newClaim.Type; } }
public UserClaims GetUserClaims() { var claimsPrincipal = _httpContextAccessor.HttpContext.User; if (_httpContextAccessor.HttpContext.User?.Identity?.IsAuthenticated ?? false) { var claims = new UserClaims() { Sub = Guid.Parse(claimsPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value), Email = claimsPrincipal.FindFirst(ClaimTypes.Email).Value, EmailVerified = bool.Parse(claimsPrincipal.FindFirst("email_verified").Value), GivenName = claimsPrincipal.FindFirst(ClaimTypes.GivenName).Value, FamilyName = claimsPrincipal.FindFirst(ClaimTypes.Surname).Value }; return(claims); } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="ApiScope"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="displayName">The display name.</param> /// <param name="userClaims">List of associated user claims that should be included when this resource is requested.</param> /// <exception cref="System.ArgumentNullException">name</exception> public ApiScope(string name, string displayName, IEnumerable <string> userClaims) { if (name.IsMissing()) { throw new ArgumentNullException(nameof(name)); } Name = name; DisplayName = displayName; if (!userClaims.IsNullOrEmpty()) { foreach (var type in userClaims) { UserClaims.Add(type); } } }
public async Task <UserClaims> LoginPasswordAsync(string clientId, string clientSecret, User user) { UserClaims password = null; using (var con = await _sql.OpenConnetctionAsync()) { password = await con.QueryFirstOrDefaultAsync <UserClaims>("Auth_Password_sp", new { ClientId = clientId, ClientSecrete = clientSecret, user.Password, user.Email, ExpirationDate = DateTime.UtcNow.AddHours(_authConfiguration.RefreshToken_TimeValidHour) }, commandType : System.Data.CommandType.StoredProcedure); } return(password); }
public async Task<IActionResult> ManageUserClaim(string userId) { var user = await userManager.FindByIdAsync(userId); if (user == null) { ViewBag.ErrorMessage = $"User Id {user.Id} is not here"; return View("NotFound"); } var existingUserClaims = await userManager.GetClaimsAsync(user); var model = new UserClaimViewModel { UserId = userId }; foreach (Claim claim in ClaimsStore.AllClaims) { UserClaims userClaims = new UserClaims { ClaimTyope = claim.Type }; //If the user has Claims, Set IsSelected Property is True, so the checkbox // next to the claim is checked on ui . if (existingUserClaims.Any(c => c.Type == claim.Type)) { userClaims.IsSelected = true; } else { userClaims.IsSelected = false; } model.Claims.Add(userClaims); } return View(model); }
public override bool Equals(object obj) { var other = obj as IdentityResourceModel; if (other == null) { return(false); } var result = UserClaims.SafeListEquals(other.UserClaims) && Description.SafeEquals(other.Description) && DisplayName.SafeEquals(other.DisplayName) && Enabled.SafeEquals(other.Enabled) && Emphasize.SafeEquals(other.Emphasize) && Required.SafeEquals(other.Required) && ShowInDiscoveryDocument.SafeEquals(other.ShowInDiscoveryDocument); return(result); }
private JwtSecurityToken CreateJwtToken(UserClaims userClaims, Guid tokenId) { var claims = new List <Claim> { new Claim("TokenId", tokenId.ToString()) }; claims.AddRange(userClaims.ToTokenClaims()); var jwtPayload = new JwtPayload( issuer: _jwtConfig.Issuer, audience: _jwtConfig.Audience, claims: claims, notBefore: null, expires: DateTime.UtcNow.AddDays(_jwtConfig.RefreshTokenExpirationInDays)); var jwtHeader = new JwtHeader(_tokenSigningCredentials); return(new JwtSecurityToken(jwtHeader, jwtPayload)); }
public async Task <IActionResult> AddDirectLead([FromBody] DirectLead obj) { try { if (ModelState.IsValid) { ClaimsIdentity claimsIdentity = User.Identity as ClaimsIdentity; var currentLoginUserid = new UserClaims(claimsIdentity).LoggedInUserId; var currentLoginUserOrgid = new UserClaims(claimsIdentity).OrgId; var config = new MapperConfiguration(cfg => { cfg.CreateMap <DirectLead, DirectLeadDTO>(); }); obj.createdBy = currentLoginUserid; obj.orgId = currentLoginUserOrgid; IMapper mapperResponse = config.CreateMapper(); var leadDTO = mapperResponse.Map <DirectLead, DirectLeadDTO>(obj); using (var uow = new UnitOfWork(_configs.Value.DbConnectionString)) { var result = await uow.AdvanceLeadCreator.DirectLeadAddAsync(leadDTO); uow.Commit(); return(Ok(new ApiResponse { message = ApiMessageConstants.commonAdded, data = result })); } } else { return(BadRequest(new ApiResponse { message = ApiMessageConstants.someThingWentWrong })); } } catch (Exception ex) { return(BadRequest(new ApiResponse { message = ex.Message })); } }
public IdentityResourceViewModel(string name, string displayName, IEnumerable <string> claimTypes) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentNullException(nameof(name)); } if (claimTypes.IsNullOrEmpty()) { throw new ArgumentException("Must provide at least one claim type", nameof(claimTypes)); } Name = name; DisplayName = displayName; foreach (var type in claimTypes) { UserClaims.Add(type); } }
public void ChecksForExistingRecord() { UserClaims userClaims = new UserClaims { UserId = 1, UserRole = "Admin" }; var domainData = Randomm.Create <UserOrganisationDomain>(); var requestParams = new UserOrganisationRequest { OrganisationId = domainData.OrganisationId, UserId = domainData.UserId }; _mockUserOrganisationLinksGateway.Setup(x => x.GetUserOrganisationByUserAndOrgId(requestParams.UserId, requestParams.OrganisationId)).Returns(domainData); _classUnderTest.Invoking(c => c.ExecuteCreate(requestParams, userClaims)) .Should() .Throw <Exception>(); }
public override async Task <TokenResponse> ConnectionAccessToken(UserClaims request, ServerCallContext context) { var secretClient = new KeyVaultFactory(new VaultCredentials { }).CreateVaultClient(); try { var secret = await secretClient.GetSecretAsync("Temp"); return(new TokenResponse { AccessToken = secret.Value.Value, ExpiresIn = 3600, TokenType = "secret" }); } catch (Exception ex) { Console.WriteLine(ex); throw ex.InnerException; } }
public async Task <IList <Claim> > GetClaimsAsync(ApplicationUser user, CancellationToken cancellationToken) { ThrowIfDisposed(); if (user == null) { throw new ArgumentNullException(nameof(user)); } var userClaims = await UserClaims.Where(uc => uc.UserId.Equals(user.Id)).ToListAsync(); List <Claim> result = new List <Claim>(); foreach (var c in userClaims) { result.Add(MakeClaim(c)); } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="IdentityResource"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="displayName">The display name.</param> /// <param name="userClaims">List of associated user claims that should be included when this resource is requested.</param> /// <exception cref="System.ArgumentNullException">name</exception> /// <exception cref="System.ArgumentException">Must provide at least one claim type - claimTypes</exception> public IdentityResource(string name, string displayName, IEnumerable <string> userClaims) { if (name.IsMissing()) { throw new ArgumentNullException(nameof(name)); } if (userClaims.IsNullOrEmpty()) { throw new ArgumentException("Must provide at least one claim type", nameof(userClaims)); } Name = name; DisplayName = displayName; foreach (var type in userClaims) { UserClaims.Add(type); } }
public async Task <IActionResult> Register(RegisterModel model, string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; if (ModelState.IsValid) { var user = new Users { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { _logger.LogInformation("User created a new account with password."); //Dodato var crntuserId = _userService.GetUserId(user.UserName); var roleid = _userService.GetRoleId("User"); var role = new UserRole { RoleId = roleid, UserId = crntuserId }; var claim = new UserClaims { UserId = crntuserId, ClaimType = "Role", ClaimValue = "User" }; // Dodavanje User Claim-a var addClaim = _userService.AddUserClaim(claim); // Dodavanje uloge var addRole = _userService.AddUserToRole(role); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme); await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl); await _signInManager.SignInAsync(user, isPersistent : false); _logger.LogInformation("User created a new account with password."); return(RedirectToLocal(returnUrl)); } AddErrors(result); } return(View(model)); }
public async Task <IActionResult> UpdateTodo(TodoModel obj) { try { if (ModelState.IsValid) { ClaimsIdentity claimsIdentity = User.Identity as ClaimsIdentity; var currentLoginUserid = new UserClaims(claimsIdentity).LoggedInUserId; var currentLoginUserOrgid = new UserClaims(claimsIdentity).OrgId; var config = new MapperConfiguration(cfg => { cfg.CreateMap <TodoModel, TodoDTO>(); }); obj.createdBy = currentLoginUserid; IMapper mapperResponse = config.CreateMapper(); var todoDTO = mapperResponse.Map <TodoModel, TodoDTO>(obj); using (var uow = new UnitOfWork(_configs.Value.DbConnectionString)) { await uow.AdvanceLeadCreator.UpdateTodoAsync(todoDTO); uow.Commit(); return(Ok(new ApiResponse { message = ApiMessageConstants.commonUpdated })); } } else { return(BadRequest(new ApiResponse { message = ApiMessageConstants.someThingWentWrong })); } } catch (Exception ex) { return(BadRequest(new ApiResponse { message = ex.Message })); } }
public UserClaims GetClaims(string token) { var principal = new JwtSecurityToken(token); List <string> claims = new List <string>(); foreach (Claim claim in principal.Claims) { claims.Add(claim.Value); } UserClaims userClaims = new UserClaims() { Email = claims[0], Role = claims[1], Id = Convert.ToInt32(claims[2]) }; return(userClaims); }
public async Task <IActionResult> DeleteService([FromRoute] int serviceId) { try { UserClaims userClaims = new UserClaims { UserId = int.Parse(HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value), UserRole = HttpContext.User.FindFirst(ClaimTypes.Role).Value }; LambdaLogger.Log($"UserID:{userClaims.UserId.ToString()} UserRole:{userClaims.UserRole}"); await _deleteServiceUseCase.Execute(serviceId, userClaims).ConfigureAwait(false); return(Ok()); } catch (UseCaseException e) { return(BadRequest(e)); } }
public void AdminController_RemoveUserClaim_Success() { Users user = new Users { UserName = "******", Email = "fakeEmail" }; UserClaims userClaim = new UserClaims { Id = 1, ClaimType = "fakeClaimType", ClaimValue = "fakeClaimValue", UserId = 1 }; var cancel = new CancellationToken(); var addUserClaimModel = new AdminModel { UserClaim = userClaim }; var removeUserClaimModel = new AdminModel { UserClaim = userClaim }; var productService = new StoreProductService(_context); var userService = new UserService(_context); var mockUserStore = new Mock <IUserStore <Users> >(); mockUserStore.Setup(u => u.CreateAsync(user, cancel)); var manager = new UserManager <Users>(mockUserStore.Object, null, null, null, null, null, null, null, null); var Controller = new AdminController(productService, manager, userService, null); var addUser = userService.AddUser(user); var addUserClaim = Controller.AddUserClaim(addUserClaimModel); var getUserClaimsBefore = userService.GetUserClaims(1); Assert.Single(getUserClaimsBefore.Result); Assert.Equal("fakeClaimValue", getUserClaimsBefore.Result.First().ClaimValue); var removeUserClaim = Controller.RemoveUserClaim(removeUserClaimModel); var getUserClaimsAfter = userService.GetUserClaims(1); Assert.Empty(getUserClaimsAfter.Result); Assert.Equal("User Claim Removed!", removeUserClaim.Value); }
/// <summary> /// Removes the <paramref name="claims"/> given from the specified <paramref name="user"/>. /// </summary> /// <param name="user">The user to remove the claims from.</param> /// <param name="claims">The claim to remove.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param> /// <returns>The <see cref="Task"/> that represents the asynchronous operation.</returns> public async override Task RemoveClaimsAsync(User user, IEnumerable <Claim> claims, CancellationToken cancellationToken = default(CancellationToken)) { ThrowIfDisposed(); if (user == null) { throw new ArgumentNullException(nameof(user)); } if (claims == null) { throw new ArgumentNullException(nameof(claims)); } foreach (var claim in claims) { var matchedClaims = await UserClaims.Where(uc => uc.UserId.Equals(user.Id) && uc.ClaimValue == claim.Value && uc.ClaimType == claim.Type).ToListAsync(cancellationToken); foreach (var c in matchedClaims) { UserClaims.Remove(c); } } }