private object FindLookupObject(string searchValue, ValueTransitContext ctx)
{
if (LookupPredicate != null)
{
var foundObject = Source
.GetCachedData()
.SingleOrDefault(i => LookupPredicate.Evaluate(new ValueTransitContext(i, ctx.TransitValue)));
return(foundObject);
}
switch (Mode)
{
case LookupMode.Single:
return(Source.GetObjectsByKey(searchValue).SingleOrDefault());
case LookupMode.First:
return(Source.GetObjectsByKey(searchValue).FirstOrDefault());
case LookupMode.All:
var result = Source.GetObjectsByKey(searchValue);
return(result.Any() ? result : null);
default:
throw new ArgumentOutOfRangeException();
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
ReturnValue = Expression.Evaluate(ctx);
string valueType = ReturnValue?.GetType().Name.Truncate(30);
ctx.TraceLine($"<- ({ valueType }){ReturnValue?.ToString().Truncate(30)}");
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
if (!Condition.Evaluate(ctx))
{
ctx.Flow = TransitionFlow.SkipValue;
}
}
private bool ConditionIsTrue(ValueTransitContext ctx)
{
string transitValue = ctx.TransitValue?.ToString();
switch (Condition)
{
case "@any":
return(true);
case "@empty":
return(string.IsNullOrEmpty(transitValue));
}
if (Condition.StartsWith("@regexp:"))
{
var regex = new Regex(Condition.Replace("@regexp:", ""), RegexOptions.IgnoreCase);
return(regex.IsMatch(transitValue));
}
//if (Condition.StartsWith("{"))
//{
// return (bool)ExpressionEvaluator.Evaluate(Condition, ctx);
//}
return(transitValue?.Contains(Condition) ?? false);
}
public IEnumerable <IDataObject> GetData()
{
Migrator.Current.Tracer.TraceLine($"DataSource ({ this }) - Get data...");
uint rowCounter = 0;
foreach (var valuesObject in GetDataInternal())
{
rowCounter++;
var ctx = new ValueTransitContext(valuesObject, valuesObject);
if (Filter != null && ctx.Execute(Filter) == false)
{
continue;
}
ctx.Execute(Key);
var strKey = ctx.TransitValue?.ToString();
if (strKey.IsEmpty())
{
continue;
}
valuesObject.Key = UnifyKey(strKey);
valuesObject.RowNumber = rowCounter;
if (PrepareData != null)
{
ctx.Execute(PrepareData);
}
yield return(valuesObject);
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
base.ExecuteInternal(ctx);
if (ExpressionContext.IsEmpty(ctx.TransitValue))
{
ctx.Flow = TransitionFlow.SkipValue;
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
if (ConditionIsTrue(ctx))
{
var value = Replace(ctx);
ctx.SetCurrentValue(value);
ctx.Flow = Important ? TransitionFlow.SkipValue : TransitionFlow.Continue;
}
}
public MigrationEventTraceEntry(MigrationEvent eventType, ValueTransitContext ctx, string message)
{
EventType = eventType;
Message = message;
ObjectKey = ctx.Source.Key;
DataSetName = ctx.DataPipeline?.Name;
RowNumber = ctx.Source.RowNumber;
Query = ctx.DataPipeline?.Source.ToString();
}
public void TraceEvent(MigrationEvent eventType, ValueTransitContext ctx, string message)
{
message = FormatMessage(message);
ctx.AddTraceEntry(message, ConsoleColor.Yellow);
_migrationEvents.Add(new MigrationEventTraceEntry(eventType, ctx, message));
SendTraceMessage(message, ConsoleColor.Yellow);
}
public void TraceLine(string message, ValueTransitContext ctx = null, ConsoleColor color = ConsoleColor.White)
{
message = FormatMessage(message);
ctx?.AddTraceEntry(message, color);
if (ctx == null || ctx.Trace)
{
SendTraceMessage(message, color);
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
if (ToField.IsNotEmpty())
{
ctx.Target.SetValue(ToField, ctx.TransitValue);
}
else
{
Expression.Evaluate(ctx);
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
foreach (var childTransition in Commands)
{
TransitChild(childTransition, ctx);
if (ctx.Flow != TransitionFlow.Continue)
{
ctx.TraceLine($"Breaking {this.GetType().Name}");
break;
}
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
var target = Target.GetObjectByKeyOrCreate(ctx.Source.Key);
//target can be empty when using TransitMode = OnlyExitedObjects
if (target == null)
{
ctx.Flow = TransitionFlow.SkipObject;
return;
}
ctx.Target = target;
TraceColor = ConsoleColor.Magenta;
ctx.TraceLine($"PIPELINE '{ctx.DataPipeline.Name}' OBJECT, Row {ctx.Source.RowNumber}, Key [{ctx.Source.Key}], IsNew: {target.IsNew}");
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
if (Flow == TransitionFlow.Debug)
{
Debugger.Break();
Flow = TransitionFlow.Continue;
}
if (Flow == TransitionFlow.RiseError)
{
throw new Exception(Message.IsEmpty() ? "Error raised by Flow command!" : Message);
}
ctx.Flow = Flow;
}
public void Run()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
Tracer.TraceLine("====== Migration start ======");
try
{
foreach (string name in _mapConfig.Variables.Keys.ToList())
{
if (_mapConfig.Variables[name] is CommandBase command)
{
var ctx = new ValueTransitContext(null, null);
ctx.Execute(command);
_mapConfig.Variables[name] = ctx.TransitValue;
}
}
foreach (var pipeline in _mapConfig.Pipeline.Where(i => i.Enabled))
{
pipeline.Run();
}
}
catch (DataMigrationException e)
{
Tracer.TraceMigrationException("Error occured while pipeline processing", e);
if (ThrowExeptionOnError)
{
throw;
}
}
catch (Exception e)
{
Tracer.TraceLine(e.ToString());
if (ThrowExeptionOnError)
{
throw;
}
}
stopwatch.Stop();
Tracer.SaveLogs();
Tracer.TraceLine($"====== END {stopwatch.Elapsed.TotalMinutes} mins ======");
}
private string Replace(ValueTransitContext ctx)
{
// if (ReplaceValue.Contains("{"))
// {
// return ExpressionEvaluator.EvaluateString(ReplaceValue, ctx);
// }
if (Condition.StartsWith("@regexp:"))
{
var regex = new Regex(Condition.Replace("@regexp:", ""), RegexOptions.IgnoreCase);
return(regex.Replace(ctx.TransitValue.ToString(), ReplaceValue));
}
if (Condition == "@empty" || Condition == "@any")
{
return(ReplaceValue);
}
return(ctx.TransitValue?.ToString().Replace(Condition, ReplaceValue));
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
Init();
var value = ctx.TransitValue;
char decimalSeparator = DecimalSeparator == 0 ? MapConfig.Current.DefaultDecimalSeparator : DecimalSeparator;
try
{
var typedValue = TypeConverter.GetTypedValue(_typeCode, value, decimalSeparator, Format);
ctx.SetCurrentValue(typedValue);
}
catch (Exception e)
{
if (OnError == null)
{
throw;
}
ctx.Execute(OnError);
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
foreach (var childTransition in Commands)
{
ctx.Execute(childTransition);
if (ctx.Flow == TransitionFlow.SkipValue)
{
//if ReplaceUnit returned SkipValue then need to stop ONLY replacing sequence (hack, need to refactor to do
//it in more convenient way
ctx.Flow = TransitionFlow.Continue;
break;
}
if (ctx.Flow != TransitionFlow.Continue)
{
ctx.TraceLine($"Breaking {this.GetType().Name}");
break;
}
}
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
object lookupObject = null;
var valueToFind = ctx.TransitValue?.ToString();
if (valueToFind.IsNotEmpty())
{
lookupObject = FindLookupObject(valueToFind, ctx);
if (lookupObject == null)
{
if (TraceNotFound)
{
string message = $"Lookup ({Source}) object not found by value '{valueToFind}'\nSource row: { ctx.Source.RowNumber}, Source key: {ctx.Source.Key}";
Migrator.Current.Tracer.TraceEvent(MigrationEvent.LookupFailed, ctx, message);
}
ctx.Execute(OnNotFound);
}
}
ctx.SetCurrentValue(lookupObject);
}
protected virtual void TransitChild(T childCommand, ValueTransitContext ctx)
{
ctx.Execute(childCommand);
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
var returnValue = Expression.Evaluate(ctx);
ctx.SetCurrentValue(returnValue);
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
ctx.TraceLine(Message.Evaluate(ctx));
}
public ExpressionContext(ValueTransitContext ctx)
{
_ctx = ctx;
}
/// Method to override in client's code for custom commands. Allow to use custom logic. /// inherited from CommandBase class /// Don't call this method directly. Use Execute method of ValueTransitContext instead public abstract void ExecuteInternal(ValueTransitContext ctx);
public override void ExecuteInternal(ValueTransitContext ctx)
{
string result = Commands.Select(i => ctx.Execute(i)?.ToString()).Join("/");
ctx.SetCurrentValue(result);
}
public override void ExecuteInternal(ValueTransitContext ctx)
{
ctx.Trace = this.Trace;
}
