internal WorkItemMapper(SyncContext context)
: base(context)
{
functions = new MapperFunctions(this.EventSink, this.SourceProjectName, this.DestinationProjectName);
// make sure we have needed indexes
this.Mapping.RebuildMappingIndexes();
// explicit default
this.UseEditableProperty = false;
this.OpenTargetWorkItem = false;
this.PartialOpenTargetWorkItem = false;
}
public FieldCopier(WorkItemsStageConfiguration mapping, MapperFunctions functions, bool useEditableProperty, WorkItemType sourceType, WorkItemMap map, WorkItemType targetType, IEngineEvents engineEvents)
{
engineEvents.TraceRule("Interpreting rules for mapping '{0}' workitems to '{1}'", sourceType.Name, targetType.Name);
foreach (FieldDefinition fromField in sourceType.FieldDefinitions)
{
var rule = map.FindFieldRule(fromField.ReferenceName);
if (rule == null)
{
// if no rule -> skip field
engineEvents.NoRuleFor(sourceType, fromField.ReferenceName);
continue;
}
string targetFieldName
= rule.IsWildcard
? fromField.ReferenceName : rule.Destination;
if (string.IsNullOrWhiteSpace(rule.Destination))
{
engineEvents.TraceRule("Skip {0}", fromField.ReferenceName);
continue;
}
if (!targetType.FieldDefinitions.Contains(targetFieldName))
{
engineEvents.TraceRule("Skip {0} (Target field {1} does not exist)", fromField.ReferenceName, targetFieldName);
continue;
}
var toField = targetType.FieldDefinitions[targetFieldName];
if (!IsAssignable(useEditableProperty, fromField, toField))
{
engineEvents.TraceRule("Skip {0} (Not assignable to {1})", fromField.ReferenceName, targetFieldName);
continue;
}//if
// make the proper copier function
Action <Field, Field> copyAction;
if (rule.IsWildcard)
{
engineEvents.TraceRule("Copy {0} to {1} (Wildcard)", fromField.ReferenceName, targetFieldName);
copyAction = (src, dst) => { dst.Value = src.Value; };
}
else if (!string.IsNullOrWhiteSpace(rule.Set))
{
engineEvents.TraceRule("Set {0} to value '{1}'", targetFieldName, rule.Set);
copyAction = (src, dst) => {
engineEvents.Trace(" *** converting '{0}' to {1}", rule.Set, dst.FieldDefinition.FieldType);
SetFieldWithConstant(dst, rule.Set);
};
}
else if (!string.IsNullOrWhiteSpace(rule.SetIfNull))
{
engineEvents.TraceRule("Set {0} to value '{1}' when source is null or empty", targetFieldName, rule.SetIfNull);
copyAction = (src, dst) =>
{
if (src.Value == null || string.IsNullOrEmpty(src.Value.ToString()))
{
SetFieldWithConstant(dst, rule.SetIfNull);
}
else
{
dst.Value = src.Value;
}
};
}
else if (!string.IsNullOrWhiteSpace(rule.Translate))
{
var flags = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic;
// TODO optimize
var translatorMethod = functions.GetType().GetMethod(rule.Translate, flags);
if (translatorMethod == null)
{
engineEvents.TranslatorFunctionNotFoundUsingDefault(rule);
// default: no translation
engineEvents.TraceRule("Copy {0} to {1} (fallback)", fromField.ReferenceName, targetFieldName);
copyAction = (src, dst) => { dst.Value = src.Value; };
}
else
{
engineEvents.TraceRule("Translate {0} via {1}", targetFieldName, rule.Translate);
copyAction = (src, dst) =>
{
dst.Value = translatorMethod.Invoke(functions, new object[] { rule, map, mapping, src.Value });
};
}
}
else
{
//engineEvents.InvalidRule(rule);
engineEvents.TraceRule("Copy {0} to {1} (Explicit)", fromField.ReferenceName, targetFieldName);
// crossing fingers
copyAction = (src, dst) => { dst.Value = src.Value; };
}//if
tasks.Add(fromField, new CopyTask()
{
SourceFieldName = fromField.ReferenceName,
CopyAction = copyAction,
TargetFieldName = targetFieldName
});
}//for fields
// now the Set rules!
foreach (var rule in map.Fields)
{
if (string.IsNullOrWhiteSpace(rule.Source))
{
if (!string.IsNullOrWhiteSpace(rule.Set))
{
engineEvents.TraceRule("Set {0} to value '{1}'", rule.Destination, rule.Set);
unboundTasks.Add(new CopyTask()
{
SourceFieldName = string.Empty,
CopyAction = (src, dst) => { SetFieldWithConstant(dst, rule.Set); },
TargetFieldName = rule.Destination
});
}
else if (!string.IsNullOrWhiteSpace(rule.SetIfNull))
{
engineEvents.TraceRule("Set {0} to value '{1}' when destination is null or empty", rule.Destination, rule.SetIfNull);
unboundTasks.Add(new CopyTask()
{
SourceFieldName = string.Empty,
CopyAction = (src, dst) =>
{
if (dst.Value == null || string.IsNullOrEmpty(dst.Value.ToString()))
{
SetFieldWithConstant(dst, rule.SetIfNull);
}
},
TargetFieldName = rule.Destination
});
}
} //if
} //for
}
