void TestEnvironment_InsertTwoFieldMapToSameTargetInMappedField(MigrationTestEnvironment env, Configuration config)
{
// Map field
MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY);
mField1.valueMap = string.Empty; // set value map name to be empty string
// Map to SAME field again
MappedField defaultField = env.NewMappedField(FIELD_AREA_PATH, FIELD_PRIORITY);
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public WorkItemTypeViewModel(WorkItemTypeMappingElement workItemType, WITSessionCustomSetting customSettings)
{
m_workItemType = workItemType;
FieldMap fieldMap = customSettings.FieldMaps.FieldMap.FirstOrDefault(x => string.Equals(x.name, m_workItemType.fieldMap));
if (fieldMap != null)
{
foreach (FieldsAggregationGroup aggregatedField in fieldMap.AggregatedFields.FieldsAggregationGroup)
{
FieldMapViewModelBase fieldMapViewModel = FieldMapViewModelFactory.CreateInstance(aggregatedField, customSettings);
if (fieldMapViewModel != null)
{
m_fieldMaps.Add(fieldMapViewModel);
}
}
foreach (MappedField mappedField in fieldMap.MappedFields.MappedField)
{
FieldMapViewModelBase fieldMapViewModel = FieldMapViewModelFactory.CreateInstance(mappedField, customSettings);
if (fieldMapViewModel != null)
{
m_fieldMaps.Add(fieldMapViewModel);
}
}
}
}
public void SetMissingStateReasonFieldMap(MigrationTestEnvironment env, Configuration config)
{
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
MappedField mField1 = env.NewMappedField(CoreFieldReferenceNames.State, CoreFieldReferenceNames.Title);
MappedField mField2 = env.NewMappedField(CoreFieldReferenceNames.Reason, CoreFieldReferenceNames.Description);
fieldMap.MappedFields.MappedField.Add(mField1);
fieldMap.MappedFields.MappedField.Add(mField2);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
private void TestEnvironment_FieldMapToEmpty(MigrationTestEnvironment env, Configuration config)
{
// Map field
MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, String.Empty);
mField1.valueMap = string.Empty; // set value map name to be empty string
// Map the rest of the fields using wild card
MappedField defaultField = env.NewMappedField("*", "*");
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
private void SetFieldMap_NoWildCardMap(Configuration config)
{
// Map Description to an invalide field
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_DESCRIPTION;
mField1.RightName = FIELD_DESCRIPTION;
mField1.MapFromSide = SourceSideTypeEnum.Left;
// The field map does not have a wild card mapping like below:
// Map the rest of the fields using wild card
//MappedField defaultField = new MappedField();
//defaultField.LeftName = "*";
//defaultField.RightName = "*";
//defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
//fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetMissingStateReasonFieldMap(Configuration config)
{
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
MappedField mField1 = new MappedField();
mField1.LeftName = CoreFieldReferenceNames.State;
mField1.RightName = CoreFieldReferenceNames.Title;
mField1.MapFromSide = SourceSideTypeEnum.Left;
MappedField mField2 = new MappedField();
mField2.LeftName = CoreFieldReferenceNames.Reason;
mField2.RightName = CoreFieldReferenceNames.Description;
mField2.MapFromSide = SourceSideTypeEnum.Left;
fieldMap.MappedFields.MappedField.Add(mField1);
fieldMap.MappedFields.MappedField.Add(mField2);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetExcludePriorityFieldMap(MigrationTestEnvironment env, Configuration config)
{
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
MappedField mField1 = env.NewMappedField(FIELD_TITLE, FIELD_TITLE);
mField1.MapFromSide = env.GetSourceSideTypeEnum();
MappedField mField2 = env.NewMappedField(FIELD_DESCRIPTION, String.Empty);
mField2.MapFromSide = env.GetSourceSideTypeEnum();
fieldMap.MappedFields.MappedField.Add(mField1);
fieldMap.MappedFields.MappedField.Add(mField2);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetExcludePriorityFieldMap(Configuration config)
{
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_TITLE;
mField1.RightName = FIELD_TITLE;
mField1.MapFromSide = SourceSideTypeEnum.Left;
MappedField mField2 = new MappedField();
mField2.LeftName = FIELD_DESCRIPTION;
mField2.RightName = string.Empty;
mField2.MapFromSide = SourceSideTypeEnum.Left;
fieldMap.MappedFields.MappedField.Add(mField1);
fieldMap.MappedFields.MappedField.Add(mField2);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
private void SetFieldMap_NoWildCardMap(MigrationTestEnvironment env, Configuration config)
{
// Map Description to an invalide field
MappedField mField1 = env.NewMappedField(FIELD_DESCRIPTION, FIELD_DESCRIPTION);
// The field map does not have a wild card mapping like below:
// Map the rest of the fields using wild card
//MappedField defaultField = env.NewMappedField("*","*");
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
//fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetAggregatedFieldMap(MigrationTestEnvironment env, Configuration config)
{
// Aggregated fields
AggregatedFields aggregatedFields = new AggregatedFields();
FieldsAggregationGroup group = new FieldsAggregationGroup();
group.MapFromSide = env.GetSourceSideTypeEnum();
group.TargetFieldName = FIELD_DESCRIPTION;
group.Format = AggregationFormat;
SourceField f0 = new SourceField();
f0.Index = 0;
f0.SourceFieldName = FIELD_TITLE;
SourceField f1 = new SourceField();
f1.Index = 1;
f1.SourceFieldName = "System.Rev";
group.SourceField.Add(f0);
group.SourceField.Add(f1);
aggregatedFields.FieldsAggregationGroup.Add(group);
// construct FieldMap
// Map all fields explictly using wildcard
MappedField defaultField = env.NewMappedField("*", "*");
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
// TODO: Create another test case for aggreated fields feature
// Construct configurations with conflicting field maps
//MappedField mField1 = env.NewMappedField(FIELD_TITLE,FIELD_DESCRIPTION);
//MappedField mField2 = env.NewMappedField(FIELD_DESCRIPTION,FIELD_TITLE);
//fieldMap.MappedFields.MappedField.Add(mField1);
//fieldMap.MappedFields.MappedField.Add(mField2);
fieldMap.AggregatedFields = aggregatedFields;
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetConditionalWildcardPriorityValueMap(Configuration config)
{
// Map P2 to P1
Value v1 = new Value();
v1.LeftValue = "2";
v1.RightValue = "1";
ValueMap vMap = new ValueMap();
vMap.name = "PriorityValueMap";
vMap.Value.Add(v1);
Value v2 = new Value();
v2.LeftValue = "*";
v2.RightValue = "3";
v2.When.ConditionalSrcFieldName = "System.Description";
v2.When.ConditionalSrcFieldValue = ConditionalValueMapDescription;
vMap.Value.Add(v2);
// Map field
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_PRIORITY;
mField1.RightName = FIELD_PRIORITY;
mField1.MapFromSide = SourceSideTypeEnum.Left;
mField1.valueMap = vMap.name;
// Map the rest of the fields using wild card
MappedField defaultField = new MappedField();
defaultField.LeftName = "*";
defaultField.RightName = "*";
defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.ValueMaps.ValueMap.Add(vMap);
SetWitSessionCustomSetting(config, customSetting);
}
void TestEnvironment_InsertWronglyIndexedAggrSrcField(Configuration config)
{
// Aggregated fields
AggregatedFields aggregatedFields = new AggregatedFields();
FieldsAggregationGroup group = new FieldsAggregationGroup();
group.MapFromSide = SourceSideTypeEnum.Left;
group.TargetFieldName = FIELD_DESCRIPTION;
group.Format = AggregationFormat;
// NOTE: both source fields are assigned with indice 10
SourceField f0 = new SourceField();
f0.Index = 10;
f0.SourceFieldName = FIELD_TITLE;
SourceField f1 = new SourceField();
f1.Index = 10;
f1.SourceFieldName = FIELD_DESCRIPTION;
group.SourceField.Add(f0);
group.SourceField.Add(f1);
aggregatedFields.FieldsAggregationGroup.Add(group);
// construct FieldMap
// Map all fields explictly using wildcard
MappedField defaultField = new MappedField();
defaultField.LeftName = "*";
defaultField.RightName = "*";
defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.AggregatedFields = aggregatedFields;
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetConditionalHybridPriorityValueMap(MigrationTestEnvironment env, Configuration config)
{
// Map P2 to P1
Value v1 = env.NewValue("2", "1");
Value v2 = env.NewValue("*", "1");
v2.When.ConditionalSrcFieldName = "System.Description";
v2.When.ConditionalSrcFieldValue = ConditionalValueMapDescription;
Value v3 = env.NewValue("2", "3");
v3.When.ConditionalSrcFieldName = "System.Description";
v3.When.ConditionalSrcFieldValue = ConditionalValueMapDescription;
ValueMap vMap = new ValueMap();
vMap.name = "PriorityValueMap";
vMap.Value.Add(v1);
vMap.Value.Add(v2);
vMap.Value.Add(v3);
// Map field
MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY);
mField1.valueMap = vMap.name;
// Map the rest of the fields using wild card
MappedField defaultField = env.NewMappedField("*", "*");
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.ValueMaps.ValueMap.Add(vMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetUserValueMap(Configuration config)
{
// User Map
Value v1 = new Value();
v1.LeftValue = SourceUser;
v1.RightValue = TargetUser;
ValueMap vMap = new ValueMap();
vMap.name = "UserMap";
vMap.Value.Add(v1);
// Map field
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_ASSIGNEDTO;
mField1.RightName = FIELD_ASSIGNEDTO;
mField1.MapFromSide = SourceSideTypeEnum.Left;
mField1.valueMap = vMap.name;
// Map the rest of the fields using wild card
MappedField defaultField = new MappedField();
defaultField.LeftName = "*";
defaultField.RightName = "*";
defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.ValueMaps.ValueMap.Add(vMap);
SetWitSessionCustomSetting(config, customSetting);
}
private void SetInvalidFieldValueMap(Configuration config)
{
ValueMap vMap = new ValueMap();
vMap.name = "PriorityValues";
var value = new Value();
value.LeftValue = "*";
value.RightValue = "10000";
vMap.Value.Add(value);
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_PRIORITY;
mField1.RightName = FIELD_PRIORITY;
mField1.MapFromSide = SourceSideTypeEnum.Left;
mField1.valueMap = "PriorityValues";
// Map the rest of the fields using wild card
MappedField defaultField = new MappedField();
defaultField.LeftName = "*";
defaultField.RightName = "*";
defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.ValueMaps.ValueMap.Add(vMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void SetUserValueMap(MigrationTestEnvironment env, Configuration config)
{
// User Map
Value v1 = env.NewValue(SourceUser, TargetUser);
ValueMap vMap = new ValueMap();
vMap.name = "UserMap";
vMap.Value.Add(v1);
// Map field
MappedField mField1 = env.NewMappedField(FIELD_ASSIGNEDTO, FIELD_ASSIGNEDTO);
mField1.valueMap = vMap.name;
// Map the rest of the fields using wild card
MappedField defaultField = env.NewMappedField("*", "*");
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.ValueMaps.ValueMap.Add(vMap);
SetWitSessionCustomSetting(config, customSetting);
}
private void SetEmptyValueMapNameInFieldMap(Configuration config)
{
// Map field
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_PRIORITY;
mField1.RightName = FIELD_PRIORITY;
mField1.MapFromSide = SourceSideTypeEnum.Left;
mField1.valueMap = string.Empty; // set value map name to be empty string
// Map the rest of the fields using wild card
MappedField defaultField = new MappedField();
defaultField.LeftName = "*";
defaultField.RightName = "*";
defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
void TestEnvironment_InsertTwoFieldMapFromSameSourceInMappedField(Configuration config)
{
// Map field
MappedField mField1 = new MappedField();
mField1.LeftName = FIELD_PRIORITY;
mField1.RightName = FIELD_PRIORITY;
mField1.MapFromSide = SourceSideTypeEnum.Left;
mField1.valueMap = string.Empty; // set value map name to be empty string
// Map to SAME field again
MappedField defaultField = new MappedField();
defaultField.LeftName = FIELD_PRIORITY;
defaultField.RightName = FIELD_AREA_PATH;
defaultField.MapFromSide = SourceSideTypeEnum.Left;
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
SetWitSessionCustomSetting(config, customSetting);
}
private void SetInvalidFieldValueMap(MigrationTestEnvironment env, Configuration config)
{
ValueMap vMap = new ValueMap();
vMap.name = "PriorityValues";
var value = env.NewValue("*", "10000");
vMap.Value.Add(value);
MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY);
mField1.valueMap = "PriorityValues";
// Map the rest of the fields using wild card
MappedField defaultField = env.NewMappedField("*", "*");
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.ValueMaps.ValueMap.Add(vMap);
SetWitSessionCustomSetting(config, customSetting);
}
public void MapWorkItemTypeFieldValues(string itemId, XmlDocument workItemDescriptionDocument, Guid sourceId)
{
XmlDocument copy = new XmlDocument();
copy.LoadXml(workItemDescriptionDocument.OuterXml);
XmlElement rootNode = workItemDescriptionDocument.DocumentElement;
if (null == rootNode)
{
throw new MigrationException(MigrationToolkitResources.InvalideChangeActionDescription, itemId);
}
bool isLeft = DecideSidenessInConfig(sourceId, m_session);
SourceSideTypeEnum sourceSide = isLeft ? SourceSideTypeEnum.Left : SourceSideTypeEnum.Right;
MapOwnerUserId(rootNode, sourceSide);
#region Map work item type
string sourceWorkItemType = rootNode.Attributes["WorkItemType"].Value;
WorkItemTypeMappingElement typeMapEntry =
m_session.WITCustomSetting.WorkItemTypes.GetMappingEntry(sourceSide, sourceWorkItemType);
if (null == typeMapEntry)
{
throw new UnmappedWorkItemTypeException(sourceWorkItemType);
}
string targetWorkItemType = m_session.WITCustomSetting.WorkItemTypes.GetMappedType(
sourceSide,
sourceWorkItemType,
typeMapEntry);
rootNode.SetAttribute("WorkItemType", targetWorkItemType);
#endregion
if (null == typeMapEntry || /* backward compatibility */
string.IsNullOrEmpty(typeMapEntry.fieldMap) || /* backward compatibility */
typeMapEntry.fieldMap.Equals(WitMappingConfigVocab.All, StringComparison.OrdinalIgnoreCase))
{
XmlNode columnsNode = rootNode.SelectSingleNode("/WorkItemChanges/Columns");
if (null == columnsNode)
{
throw new MigrationException(MigrationToolkitResources.InvalideChangeActionDescription, itemId);
}
XmlNodeList columns = rootNode.SelectNodes("/WorkItemChanges/Columns/Column");
if (null == columns)
{
throw new MigrationException(MigrationToolkitResources.InvalideChangeActionDescription, itemId);
}
List <XmlNode> fieldsToExclude = new List <XmlNode>();
foreach (XmlNode fieldColumn in columnsNode)
{
if (IsSkippingField(fieldColumn))
{
fieldsToExclude.Add(fieldColumn);
}
}
foreach (XmlNode excludedField in fieldsToExclude)
{
excludedField.ParentNode.RemoveChild(excludedField);
}
fieldsToExclude.Clear();
}
else
{
#region look up the field map entry to use
FieldMap fieldMapEntry = null;
foreach (FieldMap fieldMap in m_session.WITCustomSetting.FieldMaps.FieldMap)
{
if (fieldMap.name == typeMapEntry.fieldMap)
{
fieldMapEntry = fieldMap;
break;
}
}
#endregion
#region Map field and value
if (null != fieldMapEntry)
{
XmlNode columnsNode = rootNode.SelectSingleNode("/WorkItemChanges/Columns");
if (null == columnsNode)
{
throw new MigrationException(MigrationToolkitResources.InvalideChangeActionDescription, itemId);
}
#region map aggregated fields
List <string> aggregatedFields = new List <string>(); // store the aggregated fields so that we won't delete them later
if (fieldMapEntry.AggregatedFields.FieldsAggregationGroup.Count() > 0)
{
foreach (var fieldsGroup in fieldMapEntry.AggregatedFields.FieldsAggregationGroup)
{
if (fieldsGroup.MapFromSide != sourceSide || fieldsGroup.SourceField.Count == 0)
{
continue;
}
bool canUseMappingConfig = true;
// apply value map to the aggregated fields and identify the field columns
// Note:
// 1. Aggregated fields may appear in normal field maps
// 2. If an aggregated field does not appear in normal field map,
// the field will be dropped after the translation
// 3. If a field appear in both aggregated and normal field mapping,
// it may use different value maps
foreach (SourceField srcField in fieldsGroup.SourceField)
{
XmlNode srcFieldCol = rootNode.SelectSingleNode(
string.Format("/WorkItemChanges/Columns/Column[@ReferenceName='{0}']", srcField.SourceFieldName));
if (null != srcFieldCol)
{
// map field value and cache the result
srcField.FieldColumnNode = srcFieldCol;
string mappedValue;
if (GetMappedFieldValue(sourceSide, srcFieldCol.FirstChild.InnerText, srcField.valueMap, copy.DocumentElement, out mappedValue))
{
srcField.MappedValue = mappedValue;
}
else
{
srcField.MappedValue = srcFieldCol.FirstChild.InnerText;
}
}
else
{
// one of the aggregated field is not present in the WIT description document
TraceManager.TraceInformation(
"Aggregating field '{0}' is not in the WIT update document of Change Action {1}'",
srcField.SourceFieldName,
itemId);
canUseMappingConfig = false;
break;
}
}
if (!canUseMappingConfig)
{
continue;
}
string[] srcFieldValues = new string[fieldsGroup.SourceField.Count];
foreach (SourceField srcField in fieldsGroup.SourceField)
{
if (srcField.Index >= 0 && srcField.Index < srcFieldValues.Length)
{
srcFieldValues[srcField.Index] = srcField.MappedValue ?? string.Empty;
}
else
{
TraceManager.TraceError(
"Source aggregation field '{0}' has a wrong index of '{1}' in the configuration.",
srcField.SourceFieldName ?? string.Empty, srcField.Index.ToString());
}
}
for (int i = 0; i < srcFieldValues.Length; ++i)
{
if (srcFieldValues[i] == null)
{
TraceManager.TraceError(
"Aggregated field format '{0}' has NULL value at index '{1}'.",
fieldsGroup.Format, i.ToString());
canUseMappingConfig = false;
}
}
if (!canUseMappingConfig)
{
continue;
}
try
{
string aggregatedFieldName = fieldsGroup.TargetFieldName;
string aggregatedFieldValue = string.Format(
System.Globalization.CultureInfo.InvariantCulture,
fieldsGroup.Format, srcFieldValues);
// first, try looking for the field in the document (the field may exist on source side
// and included in the delta document)
XmlNode aggregatedFieldInDoc = rootNode.SelectSingleNode(
string.Format("/WorkItemChanges/Columns/Column[@ReferenceName='{0}']", aggregatedFieldName));
if (null == aggregatedFieldInDoc)
{
XmlElement aggregatedFieldCol = columnsNode.OwnerDocument.CreateElement("Column");
aggregatedFieldCol.SetAttribute("ReferenceName", aggregatedFieldName);
aggregatedFieldCol.SetAttribute("Type", string.Empty);
aggregatedFieldCol.SetAttribute("DisplayName", string.Empty);
columnsNode.AppendChild(aggregatedFieldCol);
XmlElement v = columnsNode.OwnerDocument.CreateElement("Value");
v.InnerText = aggregatedFieldValue;
aggregatedFieldCol.AppendChild(v);
}
else
{
aggregatedFieldInDoc.FirstChild.InnerText = aggregatedFieldValue;
}
aggregatedFields.Add(aggregatedFieldName);
}
catch (System.FormatException formatException)
{
TraceManager.TraceException(formatException);
}
}
}
#endregion
// map field and values
XmlNodeList columns = rootNode.SelectNodes("/WorkItemChanges/Columns/Column");
if (null == columns)
{
throw new MigrationException(MigrationToolkitResources.InvalideChangeActionDescription, itemId);
}
List <XmlNode> fieldsToExclude = new List <XmlNode>();
foreach (XmlNode fieldColumn in columns)
{
string srcFieldRefName = fieldColumn.Attributes["ReferenceName"].Value;
string srcFieldValue = fieldColumn.FirstChild.InnerText;
MappedField mappedFieldEntry = fieldMapEntry.MappedFields.GetMappedFieldEntry(
sourceSide, srcFieldRefName);
if (null == mappedFieldEntry)
{
if (!aggregatedFields.Contains(srcFieldRefName, StringComparer.OrdinalIgnoreCase))
{
// record the unmapped fields and delete them after the field/value mapping is applied
// aggregated fields are added by us and are target-specific - they shouldn't be deleted
fieldsToExclude.Add(fieldColumn);
}
continue;
}
else
{
string mapFromField = (isLeft ? mappedFieldEntry.LeftName : mappedFieldEntry.RightName);
if (mapFromField.Equals(WitMappingConfigVocab.Any, StringComparison.OrdinalIgnoreCase))
{
if (IsSkippingField(fieldColumn))
{
fieldsToExclude.Add(fieldColumn);
}
}
}
string tgtFieldRefName = fieldMapEntry.MappedFields.GetMappedFieldName(sourceSide, srcFieldRefName, mappedFieldEntry);
if (string.IsNullOrEmpty(tgtFieldRefName))
{
// record the fields that are mapped to "", semantically the field is excluded on target side
fieldsToExclude.Add(fieldColumn);
continue;
}
MapFieldValue(fieldMapEntry, sourceSide, fieldColumn, srcFieldRefName, tgtFieldRefName, srcFieldValue, mappedFieldEntry.valueMap, copy.DocumentElement);
fieldColumn.Attributes["ReferenceName"].Value = tgtFieldRefName;
}
// delete the unmapped fields
foreach (XmlNode unmappedField in fieldsToExclude)
{
unmappedField.ParentNode.RemoveChild(unmappedField);
}
fieldsToExclude.Clear();
aggregatedFields.Clear();
// apply missing field & default values
var missingFieldMappings = fieldMapEntry.MappedFields.GetMissingFieldEntries(sourceSide);
foreach (MappedField mappedFieldEntry in missingFieldMappings)
{
if (null == mappedFieldEntry)
{
continue;
}
string missingFieldName = (sourceSide == SourceSideTypeEnum.Left ? mappedFieldEntry.RightName : mappedFieldEntry.LeftName);
XmlElement missingField = columnsNode.OwnerDocument.CreateElement("Column");
missingField.SetAttribute("ReferenceName", missingFieldName);
missingField.SetAttribute("Type", string.Empty);
missingField.SetAttribute("DisplayName", string.Empty);
columnsNode.AppendChild(missingField);
// note missing fields do not have "from" value, hence User Id lookup is not needed.
string missingFieldValue = string.Empty;
if (!string.IsNullOrEmpty(mappedFieldEntry.valueMap))
{
string mappedValue;
if (GetMappedFieldValue(sourceSide, missingFieldValue, mappedFieldEntry.valueMap, copy.DocumentElement, out mappedValue))
{
missingFieldValue = mappedValue;
}
else
{
// use the source value when there is no value map, i.e.
// missingFieldValue = missingFieldValue;
}
}
XmlElement v = columnsNode.OwnerDocument.CreateElement("Value");
v.InnerText = missingFieldValue;
missingField.AppendChild(v);
}
}
#endregion
}
}
void TestEnvironment_InsertTwoFieldMapFromSameSourceInMappedFieldRight(MigrationTestEnvironment env, Configuration config)
{
// Map field
MappedField mField1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY);
mField1.MapFromSide = env.GetTargetSideTypeEnum();
mField1.valueMap = string.Empty; // set value map name to be empty string
// Map to SAME field again
MappedField defaultField = env.NewMappedField(FIELD_PRIORITY, FIELD_AREA_PATH);
defaultField.MapFromSide = env.GetTargetSideTypeEnum();
FieldMap fieldMap = new FieldMap();
fieldMap.name = "BugToBugFieldMap";
fieldMap.MappedFields.MappedField.Add(defaultField);
fieldMap.MappedFields.MappedField.Add(mField1);
// Map work item type
WorkItemTypeMappingElement typeMapping = new WorkItemTypeMappingElement();
typeMapping.LeftWorkItemTypeName = "Bug";
typeMapping.RightWorkItemTypeName = "Bug";
typeMapping.fieldMap = fieldMap.name;
//=================== another work item type mapping
MappedField mField1_1 = env.NewMappedField(FIELD_PRIORITY, FIELD_PRIORITY);
mField1_1.MapFromSide = SourceSideTypeEnum.Right;
mField1_1.valueMap = string.Empty; // set value map name to be empty string
// Map to SAME field again
MappedField defaultField_1 = env.NewMappedField(FIELD_PRIORITY, FIELD_AREA_PATH);
defaultField_1.MapFromSide = SourceSideTypeEnum.Right;
FieldMap fieldMap_1 = new FieldMap();
fieldMap_1.name = "BugToBugFieldMap_1";
fieldMap_1.MappedFields.MappedField.Add(defaultField_1);
fieldMap_1.MappedFields.MappedField.Add(mField1_1);
// Map work item type
WorkItemTypeMappingElement typeMapping_1 = new WorkItemTypeMappingElement();
typeMapping_1.LeftWorkItemTypeName = "Bug_1";
typeMapping_1.RightWorkItemTypeName = "Bug_1";
typeMapping_1.fieldMap = fieldMap_1.name;
// Build WIT Session custom setting
WITSessionCustomSetting customSetting = new WITSessionCustomSetting();
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping);
customSetting.WorkItemTypes.WorkItemType.Add(typeMapping_1);
customSetting.FieldMaps.FieldMap.Add(fieldMap);
customSetting.FieldMaps.FieldMap.Add(fieldMap_1);
SetWitSessionCustomSetting(config, customSetting);
}
protected void Initialize(string targetField, string targetWorkItemType)
{
// find workItemType
if (m_conflictRuleViewModel.RTConflict.SourceSideMigrationSource == null)
{
m_conflictRuleViewModel.RTConflict.SourceSideMigrationSourceReference.Load();
}
Guid migrationSourceUniqueId = m_conflictRuleViewModel.RTConflict.SourceSideMigrationSource.UniqueId;
var leftSources = m_configuration.SessionGroup.Sessions.Session.Select(x => x.LeftMigrationSourceUniqueId);
if (leftSources.Contains(migrationSourceUniqueId.ToString())) // conflict happens on left side
{
IsLeftSidedConflict = true;
WorkItemTypeMappingElement workItemTypeMapping = m_session.WITCustomSetting.WorkItemTypes.WorkItemType.FirstOrDefault(x => string.Equals(x.LeftWorkItemTypeName, targetWorkItemType));
if (workItemTypeMapping != null && !string.IsNullOrEmpty(workItemTypeMapping.fieldMap))
{
// try to find mappedField
m_fieldMap = m_session.WITCustomSetting.FieldMaps.FieldMap.FirstOrDefault(x => string.Equals(x.name, workItemTypeMapping.fieldMap));
if (m_fieldMap != null)
{
m_fieldsAggregationGroup = m_fieldMap.AggregatedFields.FieldsAggregationGroup.FirstOrDefault(x => string.Equals(x.TargetFieldName, targetField) && x.MapFromSide == SourceSideTypeEnum.Right);
if (m_fieldsAggregationGroup != null)
{
SourceField = targetField;
}
else
{
m_mappedField = m_fieldMap.MappedFields.MappedField.FirstOrDefault(x => string.Equals(x.LeftName, targetField));
if (m_mappedField != null)
{
SourceField = m_mappedField.RightName;
}
else
{
SourceField = targetField;
}
}
}
}
}
else // conflict happens on right side
{
IsLeftSidedConflict = false;
Debug.Assert(m_configuration.SessionGroup.Sessions.Session.Select(x => x.RightMigrationSourceUniqueId).Contains(migrationSourceUniqueId.ToString()));
// try to find workItemTypeMapping
WorkItemTypeMappingElement workItemTypeMapping = m_session.WITCustomSetting.WorkItemTypes.WorkItemType.FirstOrDefault(x => string.Equals(x.RightWorkItemTypeName, targetWorkItemType));
if (workItemTypeMapping != null && !string.IsNullOrEmpty(workItemTypeMapping.fieldMap))
{
// try to find mappedField
m_fieldMap = m_session.WITCustomSetting.FieldMaps.FieldMap.FirstOrDefault(x => string.Equals(x.name, workItemTypeMapping.fieldMap));
if (m_fieldMap != null)
{
m_fieldsAggregationGroup = m_fieldMap.AggregatedFields.FieldsAggregationGroup.FirstOrDefault(x => string.Equals(x.TargetFieldName, targetField) && x.MapFromSide == SourceSideTypeEnum.Left);
if (m_fieldsAggregationGroup != null)
{
SourceField = targetField;
}
else
{
m_mappedField = m_fieldMap.MappedFields.MappedField.FirstOrDefault(x => string.Equals(x.RightName, targetField));
if (m_mappedField != null)
{
SourceField = m_mappedField.LeftName;
}
else
{
SourceField = targetField;
}
}
}
}
}
}
