public void Copy(WorkItem source, WorkItem target, IEngineEvents engineEvents)
{
foreach (Field fromField in source.Fields)
{
try
{
CopyTask copier;
if (tasks.TryGetValue(fromField.FieldDefinition, out copier))
{
engineEvents.Trace("Source field {0} has value '{1}'"
, fromField.ReferenceName
, LimitToFirstLine(fromField.Value));
copier.CopyAction(fromField, target.Fields[copier.TargetFieldName]);
}
}
catch (Exception ex)
{
engineEvents.ExceptionWhileCopyingField(ex, fromField);
} //try
} //for fields
foreach (var task in unboundTasks)
{
try
{
engineEvents.Trace("Assigning field {0}", task.TargetFieldName);
task.CopyAction(null, target.Fields[task.TargetFieldName]);
}
catch (Exception ex)
{
engineEvents.ExceptionWhileActingOnField(ex, task.TargetFieldName);
}//try
}
}
internal WorkItemsStageConfigurationChecker(WorkItemStore sourceWIStore, string sourceProjectName, WorkItemStore destWIStore, string destProjectName, IEngineEvents eventSink)
{
this.sourceWIStore = sourceWIStore;
this.sourceProjectName = sourceProjectName;
this.destWIStore = destWIStore;
this.destProjectName = destProjectName;
this.eventSink = eventSink;
}
public ScriptBreakpoint(ScriptProgramNode node, string file, int line, int column, IEngineEvents callback)
{
Log.InfoFormat("ScriptBreakPoint: {0} {1} {2}", file, line, column);
_node = node;
_callback = callback;
Line = line;
Column = column;
File = file;
}
public ScriptBreakpoint(ScriptProgramNode node, string file, int line, int column, IEngineEvents callback)
{
Log.InfoFormat("ScriptBreakPoint: {0} {1} {2}", file, line, column);
_node = node;
_callback = callback;
Line = line;
Column = column;
File = file;
}
internal SyncContext(SyncContext rhs)
{
this.sourceConnection = rhs.sourceConnection;
this.sourceWIStore = rhs.sourceWIStore;
this.sourceProjectName = rhs.sourceProjectName;
this.destWIStore = rhs.destWIStore;
this.destProjectName = rhs.destProjectName;
this.mapping = rhs.mapping;
this.index = rhs.index;
this.eventSink = rhs.eventSink;
}
internal SyncContext(TfsConnection sourceConnection, WorkItemStore sourceWIStore, string sourceProjectName, WorkItemStore destWIStore, string destProjectName, WorkItemsStageConfiguration mapping, WitMappingIndex index, IEngineEvents eventSink)
{
this.sourceConnection = sourceConnection;
this.sourceWIStore = sourceWIStore;
this.sourceProjectName = sourceProjectName;
this.destWIStore = destWIStore;
this.destProjectName = destProjectName;
this.mapping = mapping;
this.index = index;
this.eventSink = eventSink;
}
public static void Load(TddStud10Package package, EngineParams engineParams)
{
Logger.LogInfo("Loading Engine with solution {0}", engineParams.SolutionPath);
_package = package;
_efsWatcher = EngineFileSystemWatcher.Create(engineParams, () => RunEngine(engineParams));
_engine = _package.TddStud10Host.GetEngine();
_engineEvents = _package.TddStud10Host.GetEngineEvents();
_engineEvents.RunStateChanged.AddHandler(_package.OnRunStateChanged);
_engineEvents.RunStarting.AddHandler(_package.OnRunStarting);
_engineEvents.RunStepStarting.AddHandler(_package.OnRunStepStarting);
_engineEvents.RunStepError.AddHandler(_package.OnRunStepError);
_engineEvents.RunStepEnded.AddHandler(_package.OnRunStepEnded);
_engineEvents.RunError.AddHandler(_package.OnRunError);
_engineEvents.RunEnded.AddHandler(_package.OnRunEnded);
}
public GlobalListsStage(TfsConnection source, TfsConnection dest, IEngineEvents eventHandler)
: base(source, dest, eventHandler)
{
//no-op
}
internal MapperFunctions(IEngineEvents eventSink, string sourceProjectName, string destProjectName)
{
this.eventSink = eventSink;
this.sourceProjectName = sourceProjectName;
this.destProjectName = destProjectName;
}
// Note: To the COM programmers out there, you
// understand that IConnectionPoint::Unadvise() takes
// a registration tolken assigned by ICP::Advise().
// This is due to the fact that YOU are writing the
// code to call the client side sink and need to
// shrink the array of IUnknown*'s when a client disconnects.
// Because the ArrayList shrinks dynamically, all
// you need to do is pass in the sink to remove.
public void Unadvise(IEngineEvents itfClientImpl)
{
itfConnections.Remove(itfClientImpl);
}
// Attach or disconnect from the source of events.
public void Advise(IEngineEvents itfClientImpl)
{
itfConnections.Add(itfClientImpl);
}
public PipelineStage(TfsConnection source, TfsConnection dest, IEngineEvents eventHandler)
{
sourceConn = source;
destConn = dest;
eventSink = eventHandler;
}
public AreasAndIterationsStage(TfsConnection source, TfsConnection dest, IEngineEvents eventHandler, StageOptions options)
: base(source, dest, eventHandler)
{
this.options = options;
}
public IterationsStage(TfsConnection source, TfsConnection dest, IEngineEvents eventHandler)
: base(source, dest, eventHandler, StageOptions.Iterations)
{
}
public WorkItemsStage(TfsConnection source, TfsConnection dest, IEngineEvents eventHandler)
: base(source, dest, eventHandler)
{
//no-op
}
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
}
public SyncPipeline(PipelineConfiguration configuration, IEngineEvents eventHandler)
{
this.configuration = configuration;
eventSink = eventHandler;
}
