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