/// <summary>
/// This function is called to calculate destination values.
/// </summary>
/// <param name="loadNumber">The LoadNumber.</param>
/// <param name="rowNumber">The RowNumber.</param>
/// <param name="row">The raw parsed row data.</param>
/// <param name="methodResolvers">Method Resolver collection.</param>
/// <param name="existenceObjects">Existence Objects collection.</param>"
/// <param name="lookups">Lookup objects collection.<param name="">/
/// <param name="map">The map that describes how to compute this value.</param>
/// <param name="values">The computed row so far.</param>
/// <returns></returns>
public static string ComputeDestinationValue(int loadNumber, int rowNumber,
IList<string> row,
IDictionary<string, IMethodResolver> methodResolvers,
IDictionary<string, IExistence> existenceObjects,
IDictionary<string, ILookup> lookups,
ISourceValueMap map,
IDictionary<string, string> values)
{
var destinationValue = String.Empty;
// Case 1: Where there's no transformation function, and we just want to migrate
// data from the source to the destination (this is by far the most common case).
if (String.IsNullOrEmpty (map.Method)) {
if (String.IsNullOrEmpty (map.Value) &&
!String.IsNullOrEmpty (map.SrcColumns)) {
destinationValue = ObtainSingleValueFromSourceWithNoTransform (row, map,
lookups);
} else if (String.IsNullOrEmpty (map.SrcColumns)) {
// Case 2: We just want to take a constant value from the feedmap, and put
// it in the destination.
if (String.IsNullOrEmpty(map.Value)) {
destinationValue = String.Empty; // Null is not permitted.
}
else {
destinationValue = ProcessSingleValueWithLookupsIfSpecified(
map.Value.Trim(), map, lookups);
}
}
} else {
// Case 3: A Method tag exists. This means we want to call a transformation
// function to compute a result. The transformation function can take 1-N
// arguments, and those argument values can come out of an ILookup object,
// using the source values as keys to the lookup.
destinationValue = ComputeDestinationValueUsingTransform (loadNumber,
rowNumber, methodResolvers, existenceObjects,
lookups, row, map, values);
}
return destinationValue;
}
/// <summary>
/// This function is called when a transformation function is specified in the map for
/// this computed data value.
/// </summary>
/// <param name="loadNum">The LoadNumber.</param>
/// <param name="rowNumber">The numeric index of the row.</param>
/// <param name="methodResolvers">Method Resolver collection.</param>
/// <param name="existenceObjects">Existence Objects collection.</param>"
/// <param name="lookups">Lookup objects collection.<param name="">/
/// <param name="row">The raw data row.</param>
/// <param name="map">An ISourceValueMap that describes how to perform the calculation.
/// </param>
/// <param name="values">The computed row so far.</param>
/// <returns>The computed destination value.</returns>
public static string ComputeDestinationValueUsingTransform(int loadNum, int rowNumber,
IDictionary<string, IMethodResolver> methodResolvers,
IDictionary<string, IExistence> existenceObjects,
IDictionary<string, ILookup> lookups,
IList<string> row, ISourceValueMap map,
IDictionary<string, string> values)
{
if (String.IsNullOrEmpty (map.MethodTag)) {
throw new Exception (
String.Format ("TransformRow - have method '{0}', but no methodTag",
map.Method));
}
if (!methodResolvers.ContainsKey (map.MethodTag)) {
throw new Exception (
String.Format ("TransformRow - method tag '{0}' for method '{1}' " +
"missing from map of MethodResolvers - config error",
map.MethodTag, map.Method));
}
var args = ParseMethodArguments (row, map, lookups);
var method = methodResolvers [map.MethodTag].ResolveTransformationMethod (
map.Method);
try {
return method (loadNum, lookups, existenceObjects, values, args);
} catch (BadRowException) {
throw;
} catch (Exception ex) {
throw new Exception (
String.Format ("ComputeDestinationValueUsingTransform - transformation " +
"function {0} incorrectly threw an error {1} - this is a " +
"fatal bug in the transformation function code",
map.Method, ex.Message));
}
}
/// <summary>
/// This function handles the case where a single source column is migrated to the
/// destination column. This is the most common case.
/// </summary>
/// <param name="row">The raw data row.</param>
/// <param name="map">Map that describes how to process the row.</param>
/// <returns>The migrated destination value.</returns>
static string ObtainSingleValueFromSourceWithNoTransform(IList<string> row,
ISourceValueMap map, IDictionary<string, ILookup> lookups)
{
int iVal;
if (!int.TryParse (map.SrcColumns, out iVal)) {
throw new Exception (
String.Format ("ObtainSingleValueFromSourceWithNoTransform - {0} not " +
"parseable as int",
map.SrcColumns));
}
// single value taken from src case
if (iVal >= row.Count) {
throw new Exception (
String.Format ("ObtainSingleValueFromSourceWithNoTransform - feedmap for "
+ "destinatonRow {0} specifies srcCol {1}, but data row is only {2} cells "
+ "long", map.DestCol, iVal, row.Count));
}
var value = row [iVal].Trim ();
return ProcessSingleValueWithLookupsIfSpecified(value, map, lookups);
}