private bool CheckCondition(CleanupRule rule, SourceContext sourceContext, object capturedValue, string stringValue,
EvaluatedValue evaluation)
{
switch (rule.Condition)
{
case CleanupCondition.Empty:
{
_matched[rule.ColumnName] = evaluation.Value;
return(capturedValue == null || capturedValue as string == "");
}
case CleanupCondition.StartsWith:
{
_matched[rule.ColumnName] = rule.ConditionArgument;
return(stringValue.StartsWith(rule.ConditionArgument));
}
case CleanupCondition.EndsWith:
{
_matched[rule.ColumnName] = rule.ConditionArgument;
return(stringValue.EndsWith(rule.ConditionArgument));
}
case CleanupCondition.Equal:
{
_matched[rule.ColumnName] = rule.ConditionArgument;
return(stringValue == rule.ConditionArgument);
}
case CleanupCondition.Regex:
{
var matched = Regex.Match(stringValue, rule.ConditionArgument);
if (matched.Length > 0)
{
_matched[rule.ColumnName] = matched.Value;
return(true);
}
return(false);
}
case CleanupCondition.Contains:
{
_matched[rule.ColumnName] = rule.ConditionArgument;
return(stringValue.Contains(rule.ConditionArgument));
}
case CleanupCondition.Expression:
{
_matched[rule.ColumnName] = stringValue;
return((bool)_expressionEvaluator.Evaluate(rule.ConditionArgument));
}
default:
return(false);
}
}
private void SafeRun(Action action, SourceContext sourceContext, CleanupRule rule)
{
try
{
action();
}
catch (Exception e)
{
sourceContext.AddErrorForSourceColumn(rule.ColumnName, e, SourceContext.ErrorTypeCleanup);
}
}
private void ApplyConditionalCleanup(CleanupRule rule, SourceContext sourceContext, string stringValue,
SingleCleanupRuleResult result, EvaluatedValue evaluation)
{
switch (rule.Action)
{
case CleanupAction.Replace:
{
sourceContext.Source[rule.ColumnName] = evaluation.Value;
}
break;
case CleanupAction.ReplaceMatched:
{
if (_matched.ContainsKey(rule.ColumnName) && !string.IsNullOrEmpty(_matched[rule.ColumnName]))
{
if (string.IsNullOrEmpty(stringValue))
{
sourceContext.Source[rule.ColumnName] = evaluation.Value;
}
else
{
sourceContext.Source[rule.ColumnName] = stringValue.Replace(_matched[rule.ColumnName], evaluation.Value);
}
}
}
break;
case CleanupAction.Remove:
{
result.IsDeleted = true;
}
break;
case CleanupAction.StartLoad:
{
_frameState.StartLoad();
}
break;
case CleanupAction.StartLoadExclude:
{
_frameState.StartLoadExclude();
}
break;
case CleanupAction.StopLoad:
{
_frameState.StopLoad();
}
break;
}
}
private void Apply(CleanupRule rule, SourceContext sourceContext, SingleCleanupRuleResult result)
{
var capturedValue = sourceContext.Source[rule.ColumnName];
var stringValue = capturedValue != null?capturedValue.ToString() : "";
EnrichContextByRow(sourceContext);
Lazy <string> evaluation = new Lazy <string>(() =>
{
var evaluatedResult = _expressionEvaluator.Evaluate(rule.Expression).ToString();
return(evaluatedResult);
});
EvaluatedValue evaluatedValue = new EvaluatedValue(evaluation);
if (CheckCondition(rule, sourceContext, capturedValue, stringValue, evaluatedValue))
{
ApplyConditionalCleanup(rule, sourceContext, stringValue, result, evaluatedValue);
}
ApplyNonConditionalCleanup(rule, sourceContext, stringValue, result, evaluatedValue);
}
private void ApplyNonConditionalCleanup(CleanupRule rule, SourceContext sourceContext, string stringValue,
SingleCleanupRuleResult result, EvaluatedValue evaluation)
{
switch (rule.Action)
{
case CleanupAction.GetPrevious:
{
if (string.IsNullOrEmpty(stringValue) && _previousNonEmptyValue.ContainsKey(rule.ColumnName))
{
sourceContext.Source[rule.ColumnName] = _previousNonEmptyValue[rule.ColumnName];
}
else
{
_previousNonEmptyValue[rule.ColumnName] = stringValue;
}
}
break;
}
if (_frameState.IsLocked())
{
result.IsDeleted = true;
}
}