private bool IsRuleApplicable(RichIdentity sourceUserIdentity, AliasMapping rule, bool leftToRight)
{
string fromAlias = (leftToRight ? rule.Left : rule.Right);
if (string.IsNullOrEmpty(fromAlias))
{
return(false);
}
bool mappingRuleIsKnown = false;
switch (rule.MappingRule)
{
case MappingRules.SimpleReplacement:
case MappingRules.Ignore:
case MappingRules.FormatStringComposition:
case MappingRules.FormatStringDecomposition:
mappingRuleIsKnown = true;
break;
default:
TraceManager.TraceError("Unknown DisplayNameMapping.MappingRule type");
mappingRuleIsKnown = false;
break;
}
if (!mappingRuleIsKnown)
{
return(false);
}
return(fromAlias.Equals(UserIdentityMappingConfigSymbols.ANY, StringComparison.OrdinalIgnoreCase) ||
fromAlias.Equals(sourceUserIdentity.Alias ?? string.Empty, StringComparison.OrdinalIgnoreCase));
}
void TestEnvironment_ConfigureUserIdLookup(MigrationTestEnvironment env, Configuration config)
{
var aliasMapping = new AliasMapping();
aliasMapping.Left = "*";
aliasMapping.Right = "vseqa1";
aliasMapping.MappingRule = MappingRules.SimpleReplacement;
var aliasMappings = new AliasMappings();
aliasMappings.AliasMapping.Add(aliasMapping);
aliasMappings.DirectionOfMapping = MappingDirectionEnum.LeftToRight;
config.SessionGroup.UserIdentityMappings.AliasMappings.Add(aliasMappings);
var domainMapping = new DomainMapping();
domainMapping.Left = "*";
domainMapping.Right = "redmond";
domainMapping.MappingRule = MappingRules.SimpleReplacement;
var domainMappings = new DomainMappings();
domainMappings.DomainMapping.Add(domainMapping);
domainMappings.DirectionOfMapping = MappingDirectionEnum.LeftToRight;
config.SessionGroup.UserIdentityMappings.DomainMappings.Add(domainMappings);
config.SessionGroup.UserIdentityMappings.EnableValidation = false;
config.SessionGroup.UserIdentityMappings.UserIdentityLookupAddins.UserIdentityLookupAddin.Add(
"CDDE6B6B-72FC-43b6-BBD1-B8A89A788C6F"); // Tfs2010UserIdLookupAddin
foreach (var ms in config.SessionGroup.MigrationSources.MigrationSource)
{
ms.Settings.DefaultUserIdProperty.UserIdPropertyName = UserIdPropertyNameEnum.DomainAlias;
}
}
/// <summary>
/// Create an alias mapping on the fly.
/// This ensure the file can be changed while the app is running.
/// </summary>
private IAliasMapping CreateAliasMapping()
{
if (!File.Exists(GetAliasMappingPath()))
{
return(new NullAliasMapping());
}
var mapping = new AliasMapping(GetAliasMappingPath());
mapping.Load();
return(mapping);
}
public void MyTestInitialize()
{
var mappingsCollection = new AliasMappings();
mappingsCollection.DirectionOfMapping = MappingDirectionEnum.LeftToRight;
foreach (var mapping in m_leftToRigthMappings)
{
AliasMapping mappingRule = new AliasMapping();
mappingRule.Left = mapping.Left;
mappingRule.Right = mapping.Right;
mappingRule.MappingRule = MappingRules.SimpleReplacement;
mappingsCollection.AliasMapping.Add(mappingRule);
}
m_aliasMappings.Add(mappingsCollection);
mappingsCollection = new AliasMappings();
mappingsCollection.DirectionOfMapping = MappingDirectionEnum.RightToLeft;
foreach (var mapping in m_rightToLeftMappings)
{
AliasMapping mappingRule = new AliasMapping();
mappingRule.Left = mapping.Left;
mappingRule.Right = mapping.Right;
mappingRule.MappingRule = MappingRules.SimpleReplacement;
mappingsCollection.AliasMapping.Add(mappingRule);
}
m_aliasMappings.Add(mappingsCollection);
mappingsCollection = new AliasMappings();
mappingsCollection.DirectionOfMapping = MappingDirectionEnum.TwoWay;
foreach (var mapping in m_twoWayMappings)
{
AliasMapping mappingRule = new AliasMapping();
mappingRule.Left = mapping.Left;
mappingRule.Right = mapping.Right;
mappingRule.MappingRule = MappingRules.SimpleReplacement;
mappingsCollection.AliasMapping.Add(mappingRule);
}
foreach (var mapping in m_ignoreMappings)
{
AliasMapping mappingRule = new AliasMapping();
mappingRule.Left = mapping.Left;
mappingRule.Right = mapping.Right;
mappingRule.MappingRule = MappingRules.Ignore;
mappingsCollection.AliasMapping.Add(mappingRule);
}
m_aliasMappings.Add(mappingsCollection);
}
private bool MapUser(
RichIdentity sourceUserIdentity,
bool leftToRight,
RichIdentity mappedUserIdentity)
{
m_mappingRuleComparer.MapFromLeftToRight = leftToRight;
NotifyingCollection <AliasMapping> unidirectionalRules;
if (leftToRight)
{
if (!m_perDirectionMappings.ContainsKey(MappingDirectionEnum.LeftToRight))
{
return(false);
}
unidirectionalRules = m_perDirectionMappings[MappingDirectionEnum.LeftToRight];
}
else
{
if (!m_perDirectionMappings.ContainsKey(MappingDirectionEnum.RightToLeft))
{
return(false);
}
unidirectionalRules = m_perDirectionMappings[MappingDirectionEnum.RightToLeft];
}
bool mapped = false;
AliasMapping appliedUnidirectionalRule = null;
RichIdentity unidirectionalMappingOutput = null;
foreach (AliasMapping rule in unidirectionalRules)
{
RichIdentity mappingOutput = new RichIdentity();
if (TryApplyMappingRule(sourceUserIdentity, leftToRight, mappingOutput, rule))
{
if (appliedUnidirectionalRule == null ||
m_mappingRuleComparer.Compare(rule, appliedUnidirectionalRule) < 0)
{
appliedUnidirectionalRule = rule;
unidirectionalMappingOutput = mappingOutput;
}
mapped = true;
}
}
if (mapped)
{
mappedUserIdentity.Alias = unidirectionalMappingOutput.Alias;
return(true);
}
AliasMapping appliedBidirectionalRule = null;
RichIdentity bidirectionalMappingOutput = null;
if (m_perDirectionMappings.ContainsKey(MappingDirectionEnum.TwoWay))
{
foreach (AliasMapping rule in m_perDirectionMappings[MappingDirectionEnum.TwoWay])
{
RichIdentity mappingOutput = new RichIdentity();
if (TryApplyMappingRule(sourceUserIdentity, leftToRight, mappingOutput, rule))
{
if (appliedBidirectionalRule == null ||
m_mappingRuleComparer.Compare(rule, appliedBidirectionalRule) < 0)
{
appliedBidirectionalRule = rule;
bidirectionalMappingOutput = mappingOutput;
}
mapped = true;
}
}
}
if (mapped)
{
mappedUserIdentity.Alias = bidirectionalMappingOutput.Alias;
}
return(mapped);
}
private bool ApplyRule(RichIdentity sourceUserIdentity, bool leftToRight, RichIdentity mappingOutput, AliasMapping rule)
{
string toAlias = (leftToRight ? rule.Right : rule.Left);
IStringManipulationRule stringManipulationRule = StringManipulationRuleFactory.GetInstance(rule.MappingRule);
if (stringManipulationRule != null)
{
mappingOutput.Alias = stringManipulationRule.Apply(sourceUserIdentity.Alias, toAlias);
return(true);
}
else
{
return(false);
}
}
private bool TryApplyMappingRule(RichIdentity sourceUserIdentity, bool leftToRight, RichIdentity mappingOutput, AliasMapping rule)
{
if (IsRuleApplicable(sourceUserIdentity, rule, leftToRight))
{
return(ApplyRule(sourceUserIdentity, leftToRight, mappingOutput, rule));
}
else
{
return(false);
}
}
