public static Task <ClaimsPrincipal> AddClaims(
ClaimsTransformationContext context)
{
ClaimsPrincipal principal = context.Principal;
if (principal != null &&
!principal.HasClaim(c => c.Type == ClaimTypes.PostalCode))
{
ClaimsIdentity identity = principal.Identity as ClaimsIdentity;
if (identity != null && identity.IsAuthenticated &&
identity.Name != null)
{
if (identity.Name.ToLower() == "alice")
{
identity.AddClaims(new Claim[] {
CreateClaim(ClaimTypes.PostalCode, "DC 20500"),
CreateClaim(ClaimTypes.StateOrProvince, "DC")
});
}
else
{
identity.AddClaims(new Claim[] {
CreateClaim(ClaimTypes.PostalCode, "NY 10036"),
CreateClaim(ClaimTypes.StateOrProvince, "NY")
});
}
}
}
return(Task.FromResult(principal));
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var principal = context.Principal;
((ClaimsIdentity)principal.Identity).AddClaim(new Claim("ProjectReader", "true"));
return(Task.FromResult(principal));
}
//http://benfoster.io/blog/customising-claims-transformation-in-aspnet-core-identity
//You need to refer to the comments and discussions at the bottm to find out the code changes
//for this TransformAsync method which I have placed here.
//The purpose is to create a new Claim having the name, InstructorId
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
ClaimsPrincipal principal = context.Principal;
((ClaimsIdentity)principal.Identity).AddClaim(new Claim("InstructorId", ""));
return(Task.FromResult(principal));
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var identity = (ClaimsIdentity)context.Principal.Identity;
identity.AddClaim(new Claim("SomeValue", "value"));
return(Task.FromResult(context.Principal));
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var securityProvider = context.Context.RequestServices.GetRequiredService <ISecurityProvider>();
ClaimsPrincipal principal = new ComBoostPrincipal(securityProvider);
principal.AddIdentities(context.Principal.Identities);
return(Task.FromResult(principal));
}
private ClaimsTransformationContext CreateClaimsTransformationContext(ClaimsPrincipal user)
{
var claimsTransformationContext = new ClaimsTransformationContext(Mock.Of <HttpContext>())
{
Principal = user
};
return(claimsTransformationContext);
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
if (context.Principal.Identity.IsAuthenticated)
{
context.Principal.Identity.AddClaim("test", "example");
}
return(Task.FromResult(context.Principal));
}
public async Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var identity = (ClaimsIdentity)context.Principal.Identity;
//buscar novas claims e adicionar ao principal
identity.AddClaim(new Claim(ClaimTypes.Country, "Brasil"));
identity.AddClaim(new Claim("financial", "read write"));
return(await Task.FromResult(context.Principal));
}
public async Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var identity = ((ClaimsIdentity)context.Principal.Identity);
// ... add user claims if required
var roles = _userService.GetRoles(identity.Name);
foreach (var role in roles)
{
identity.AddClaim(new Claim(ClaimTypes.Role, role));
}
return(await Task.FromResult(context.Principal));
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var identity = (ClaimsIdentity)context.Principal.Identity;
var userName = identity.Name;
var roles = _context.Role.Where(r => r.UserRole.Any(u => u.User.Username == userName)).Select(r => r.Name);
foreach (var role in roles)
{
var claim = new Claim(ClaimTypes.Role, role);
identity.AddClaim(claim);
}
return(Task.FromResult(context.Principal));
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
ClaimsPrincipal principal = context.Principal;
ClaimsIdentity identity = (ClaimsIdentity)principal.Identity;
string claimString = NTContext.HttpContext.Session.GetString("IdentityClaims");
if (claimString != null)
{
List <ClaimModel> sessionClaims = JsonConvert.DeserializeObject <List <ClaimModel> >(claimString);
identity.AddClaims(sessionClaims.Select(sc => new Claim(sc.ClaimType, sc.ClaimValue)));
}
return(Task.FromResult(principal));
}
public async Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
if (context.Principal?.Identity?.Name == null || context.Principal?.Identities?.FirstOrDefault()?.HasClaim(c => c.Type == Claims.PermissionsType) == true)
{
return(context.Principal);
}
var userId = context.Principal.Identity.Name;
var pdpResponse = await _pdpProvider.GetPermissionsAsync(userId, _authOptions.ApplicationName);
pdpResponse?.permissions?.ToList().ForEach(permission =>
{
context.Principal.Identities.First().AddClaim(new Claim(Claims.PermissionsType, permission));
});
return(context.Principal);
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
//retrieve an instance of ApplicationDbContext
var db = (ApplicationDbContext)context.Context.RequestServices.GetService(typeof(ApplicationDbContext));
var identity = context.Principal.Identity;
var principal = context.Principal;
//get tenantContext from HttpContext
var tenantContext = context.Context.GetTenantContext <AppTenant>();
if (identity.IsAuthenticated)
{
//get Serviceplan from store; possible NullreferenceException.
var servicePlan = db.Tenants.Include(x => x.ServicePlan).FirstOrDefault(t => t.AppTenantId == tenantContext.Tenant.AppTenantId).ServicePlan;
//add new claim
((ClaimsIdentity)principal.Identity).AddClaim(new Claim("ServicePlan", servicePlan.Name));
}
return(Task.FromResult(principal));
}
public static Task <ClaimsPrincipal> AddClaims(ClaimsTransformationContext context)
{
string userName = "******";
// new claim for userName
string issuer = "Simulator";
string valueType = ClaimValueTypes.String;
string type1 = ClaimTypes.Country;
string value1 = "New Zealand";
string type2 = ClaimTypes.StateOrProvince;
string value2 = "Wellington";
// new claim for non-userName
string value = "Null";
ClaimsPrincipal principal = context.Principal;
if (principal != null && !principal.HasClaim(c => c.Type == ClaimTypes.Country))
{
ClaimsIdentity identity = principal.Identity as ClaimsIdentity;
if (identity != null && identity.IsAuthenticated && identity.Name != null)
{
if (identity.Name.ToLower() == userName.ToLower())
{
identity.AddClaims(new Claim[]
{
new Claim(type1, value1, valueType, issuer),
new Claim(type2, value2, valueType, issuer)
});
}
else // Not Joe
{
identity.AddClaims(new Claim[]
{
new Claim(type1, value, valueType, issuer),
new Claim(type2, value, valueType, issuer),
});
}
}
}
return(Task.FromResult(principal));
}
public async Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
if (context.Principal.Identity.IsAuthenticated)
{
Claim userId = context.Principal.FindFirst("sub");
if (context.Principal.FindFirst("role") == null && userId != null)
{
IPCS.Entities.User user = await _userManager.FindByIdAsync(userId.Value);
var roles = await _userManager.GetRolesAsync(user);
foreach (var role in roles)
{
((ClaimsIdentity)context.Principal.Identity).AddClaim(new Claim(ClaimTypes.Role, role));
}
}
}
return(Task.FromResult(context.Principal).Result);
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
//TODO: Clean up and simplify AdminClaimTypes Transformer
foreach (var claim in context.Principal.Claims)
{
switch (claim.Type)
{
case "userId":
_userId = claim.Value ?? _userId;
break;
}
}
((ClaimsIdentity)context.Principal.Identity)
.AddClaims(new Claim[]
{
new Claim(AdminClaimType.UserId.DisplayName, _userId)
});
return(Task.FromResult(context.Principal));
}
public Task <ClaimsPrincipal> TransformAsync(ClaimsTransformationContext context)
{
var identity = (ClaimsIdentity)context.Principal.Identity;
if (context.Context.User != null)
{
var nameClaim = context.Context.User.FindFirst(ClaimTypes.NameIdentifier);
if (nameClaim != null)
{
var userId = nameClaim.Value;
//var company = db.CompanyUsers.FirstOrDefault(x => x.UserId == userId);
//if (company != null)
//{
// var companyClaims = db.CompanyClaims.Where(x => x.CompanyId == company.CompanyId);
// foreach (var companyClaim in companyClaims)
// {
// if (!identity.HasClaim(companyClaim.ClaimType, companyClaim.ClaimValue))
// {
// identity.AddClaim(new Claim(companyClaim.ClaimType, companyClaim.ClaimValue));
// }
// }
//}
var userClaims = db.UserClaims.Where(x => x.UserId == userId);
foreach (var claim in db.UserClaims)
{
if (!identity.HasClaim(claim.ClaimType, claim.ClaimValue))
{
identity.AddClaim(new Claim(claim.ClaimType, claim.ClaimValue));
}
}
}
}
return(Task.FromResult(context.Principal));
}
/// <summary> /// Invoked after the security token has passed validation and a ClaimsIdentity has been generated. /// </summary> public virtual Task ClaimsTransformation(ClaimsTransformationContext context) => OnClaimsTransformation(context);
