private IEnumerable <Claim> ConcatenateTransformation(ClaimTransform claimTransformation, List <Claim> claims)
{
var transformedClaims = new List <Claim>();
var addTransformationClaim = false;
var values = new string[claimTransformation.ClaimsIn.Count()];
int i = 0;
foreach (var claimIn in claimTransformation.ClaimsIn)
{
var value = claims.Where(c => c.Type.Equals(claimIn, StringComparison.OrdinalIgnoreCase)).Select(c => c.Value).FirstOrDefault();
if (value != null)
{
addTransformationClaim = true;
values[i++] = value;
}
else
{
values[i++] = string.Empty;
}
}
if (addTransformationClaim)
{
var transformationValue = string.Format(claimTransformation.Transformation, values);
transformedClaims.Add(new Claim(claimTransformation.ClaimOut, transformationValue));
}
return(transformedClaims);
}
private void RegexMapTransformation(List <Claim> claims, ClaimTransform claimTransform)
{
var newClaims = new List <Claim>();
var regex = new Regex(claimTransform.Transformation, RegexOptions.IgnoreCase);
var claimIn = claimTransform.ClaimsIn.Single();
foreach (var claim in claims)
{
if (claim.Type.Equals(claimIn, StringComparison.OrdinalIgnoreCase))
{
var match = regex.Match(claim.Value);
if (match.Success && match.Groups.ContainsKey("map"))
{
newClaims.Add(new Claim(claimTransform.ClaimOut, match.Groups["map"].Value));
}
}
}
if (claimTransform.Action == ClaimTransformActions.Add || claimTransform.Action == ClaimTransformActions.Replace)
{
AddOrReplaceClaims(claims, claimTransform, newClaims);
}
else if (claimTransform.Action == ClaimTransformActions.AddIfNotOut)
{
if (!(claims.Where(c => c.Type.Equals(claimTransform.ClaimOut, StringComparison.OrdinalIgnoreCase)).Count() > 0))
{
AddOrReplaceClaims(claims, claimTransform, newClaims);
}
}
}
protected override void ProcessRecord()
{
Uri uri = null;
if (this.Type == TransformType.Add)
{
uri = new Uri(AuthorizationConstants.TransformUris.Add);
}
else if (this.Type == TransformType.Remove)
{
uri = new Uri(AuthorizationConstants.TransformUris.Remove);
}
else if (this.Type == TransformType.Replace)
{
uri = new Uri(AuthorizationConstants.TransformUris.Replace);
}
else
{
throw new ArgumentOutOfRangeException("Type");
}
ClaimTransform transform = new ClaimTransform(uri, this.MatchExpression, this.TargetClaim);
transform.Expression = this.EvaluationExpression;
WriteObject(transform);
}
private void MapTransformation(List <Claim> claims, ClaimTransform claimTransform)
{
var newClaims = new List <Claim>();
var claimIn = claimTransform.ClaimsIn.Single();
foreach (var claim in claims)
{
if (claim.Type.Equals(claimIn, StringComparison.OrdinalIgnoreCase))
{
newClaims.Add(new Claim(claimTransform.ClaimOut, claim.Value));
}
}
if (claimTransform.Action == ClaimTransformActions.Add || claimTransform.Action == ClaimTransformActions.Replace)
{
AddOrReplaceClaims(claims, claimTransform, newClaims);
}
else if (claimTransform.Action == ClaimTransformActions.AddIfNotOut)
{
if (!(claims.Where(c => c.Type.Equals(claimTransform.ClaimOut, StringComparison.OrdinalIgnoreCase)).Count() > 0))
{
AddOrReplaceClaims(claims, claimTransform, newClaims);
}
}
}
private void RegexMatchTransformation(List <Claim> claims, ClaimTransform claimTransform)
{
var regex = new Regex(claimTransform.Transformation, RegexOptions.IgnoreCase);
if (claimTransform.Action != ClaimTransformActions.Remove)
{
var newClaims = new List <Claim>();
var claimIn = claimTransform.ClaimsIn.Single();
foreach (var claim in claims)
{
if (claim.Type.Equals(claimIn, StringComparison.OrdinalIgnoreCase))
{
var match = regex.Match(claim.Value);
if (match.Success)
{
newClaims.Add(new Claim(claimTransform.ClaimOut, claimTransform.TransformationExtension));
}
}
}
if (claimTransform.Action == ClaimTransformActions.Add || claimTransform.Action == ClaimTransformActions.Replace)
{
AddOrReplaceClaims(claims, claimTransform, newClaims);
}
else if (newClaims.Count() <= 0 && (claimTransform.Action == ClaimTransformActions.AddIfNot || claimTransform.Action == ClaimTransformActions.ReplaceIfNot))
{
AddOrReplaceClaims(claims, claimTransform, new Claim(claimTransform.ClaimOut, claimTransform.TransformationExtension));
}
}
else
{
claims.RemoveAll(c => c.Type.Equals(claimTransform.ClaimOut, StringComparison.OrdinalIgnoreCase) && regex.Match(c.Value).Success);
}
}
private void MatchClaimTransformation(List <Claim> claims, ClaimTransform claimTransform)
{
if (claimTransform.Action != ClaimTransformActions.Remove)
{
var newClaims = new List <Claim>();
foreach (var claim in claims)
{
if (claim.Type.Equals(claimTransform.ClaimsIn.Single(), StringComparison.OrdinalIgnoreCase))
{
newClaims.Add(new Claim(claimTransform.ClaimOut, claimTransform.Transformation));
}
}
if (claimTransform.Action == ClaimTransformActions.Add || claimTransform.Action == ClaimTransformActions.Replace)
{
AddOrReplaceClaims(claims, claimTransform, newClaims);
}
else if (newClaims.Count() <= 0 && (claimTransform.Action == ClaimTransformActions.AddIfNot || claimTransform.Action == ClaimTransformActions.ReplaceIfNot))
{
AddOrReplaceClaims(claims, claimTransform, new Claim(claimTransform.ClaimOut, claimTransform.Transformation));
}
}
else
{
claims.RemoveAll(c => c.Type.Equals(claimTransform.ClaimOut, StringComparison.OrdinalIgnoreCase));
}
}
public static void HandleObsoleteActions(ClaimTransform ct)
{
if (ct.Action == ClaimTransformActions.AddIfNotObsolete)
{
ct.Action = ClaimTransformActions.AddIfNot;
}
else if (ct.Action == ClaimTransformActions.ReplaceIfNotObsolete)
{
ct.Action = ClaimTransformActions.ReplaceIfNot;
}
}
private IEnumerable <Claim> MatchTransformation(ClaimTransform claimTransformation, List <Claim> claims)
{
var transformedClaims = new List <Claim>();
foreach (var claim in claims)
{
if (claim.Type.Equals(claimTransformation.ClaimsIn.Single(), StringComparison.OrdinalIgnoreCase) && claim.Value.Equals(claimTransformation.Transformation, StringComparison.OrdinalIgnoreCase))
{
transformedClaims.Add(new Claim(claimTransformation.ClaimOut, claimTransformation.TransformationExtension));
}
}
return(transformedClaims);
}
private IEnumerable <Claim> RegexMatchTransformation(ClaimTransform claimTransformation, List <Claim> claims)
{
var transformedClaims = new List <Claim>();
var regex = new Regex(claimTransformation.Transformation, RegexOptions.IgnoreCase);
var claimIn = claimTransformation.ClaimsIn.Single();
foreach (var claim in claims)
{
if (claim.Type.Equals(claimIn, StringComparison.OrdinalIgnoreCase))
{
var match = regex.Match(claim.Value);
if (match.Success)
{
transformedClaims.Add(new Claim(claimTransformation.ClaimOut, claimTransformation.TransformationExtension));
}
}
}
return(transformedClaims);
}
private static void AddOrReplaceClaims(List <Claim> outputClaims, ClaimTransform claimTransform, Claim newClaim)
{
switch (claimTransform.Action)
{
case ClaimTransformActions.Add:
case ClaimTransformActions.AddIfNot:
outputClaims.Add(newClaim);
break;
case ClaimTransformActions.Replace:
case ClaimTransformActions.ReplaceIfNot:
outputClaims.RemoveAll(c => claimTransform.ClaimOut.Equals(c.Type, StringComparison.OrdinalIgnoreCase));
outputClaims.Add(newClaim);
break;
default:
throw new NotSupportedException("Claim transform action is not supported in method.");
}
}
private Claim ConstantTransformation(ClaimTransform claimTransformation)
{
return(new Claim(claimTransformation.ClaimOut, claimTransformation.Transformation));
}
private void ConstantTransformation(List <Claim> claims, ClaimTransform claimTransform)
{
var newClaim = new Claim(claimTransform.ClaimOut, claimTransform.Transformation);
AddOrReplaceClaims(claims, claimTransform, newClaim);
}
private static ClaimTransformActions MapAction(ClaimTransform ct)
{
ClaimTransformValidationLogic.HandleObsoleteActions(ct);
return(ct.Action);
}
