public string GetMappedValueWithExceptionThrower(string fieldToUpdateDescription,
SyncSide syncSideToUpdate, string nonUpdateSideValue)
{
try
{
if (syncSideToUpdate == SyncSide.Source)
{
return(GetMappedValue(null, nonUpdateSideValue, syncSideToUpdate));
}
else if (syncSideToUpdate == SyncSide.Target)
{
return(GetMappedValue(nonUpdateSideValue, null, syncSideToUpdate));
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSideToUpdate);
}
}
catch (UnmappedValueException ex)
{
UnmappedValueExceptionHandler.ThrowException(fieldToUpdateDescription, ex);
}
return(null);
}
public static bool HasManualGeneratedPrimaryKey(DataMap map, SyncSide syncSide)
{
if (GetEntityDefinition(map, syncSide).PrimaryKeyGenerationType == PrimaryKeyGenerationType.Manual)
{
return(true);
}
return(false);
}
public void AddDataSources(IEnumerable <DataSource> dataSources, SyncSide side)
{
if (dataSources != null)
{
foreach (var dataSource in dataSources)
{
AddDataSource(dataSource, side);
}
}
}
protected void AddCustomSetField(SyncSide syncSide, string fieldToCompare, string fieldToUpdate, Func <DataRow, object> customSetMethod, SyncOperation appliesTo, bool onlyApplyWithOtherChanges)
{
if (_customSetFields.Exists(d => (appliesTo.HasFlag(SyncOperation.Inserts) || appliesTo.HasFlag(SyncOperation.All)) &&
(d.AppliesTo.HasFlag(SyncOperation.Inserts) || d.AppliesTo.HasFlag(SyncOperation.All)) &&
d.SyncSide == syncSide &&
string.Equals(d.FieldNameToUpdate, fieldToUpdate, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception(string.Format("Field '{0}' already exists for operation '{1}' and sync side '{2}'.",
fieldToUpdate, Enum.GetName(typeof(SyncOperation), SyncOperation.Inserts), Enum.GetName(typeof(SyncSide), syncSide)));
}
if (_customSetFields.Exists(d => (appliesTo.HasFlag(SyncOperation.Updates) || appliesTo.HasFlag(SyncOperation.All)) &&
(d.AppliesTo.HasFlag(SyncOperation.Updates) || d.AppliesTo.HasFlag(SyncOperation.All)) &&
d.SyncSide == syncSide &&
string.Equals(d.FieldNameToUpdate, fieldToUpdate, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception(string.Format("Field '{0}' already exists for operation '{1}' and sync side '{2}'.",
fieldToUpdate, Enum.GetName(typeof(SyncOperation), SyncOperation.Updates), Enum.GetName(typeof(SyncSide), syncSide)));
}
if (_customSetFields.Exists(d => (appliesTo.HasFlag(SyncOperation.Deletes) || appliesTo.HasFlag(SyncOperation.All)) &&
(d.AppliesTo.HasFlag(SyncOperation.Deletes) || d.AppliesTo.HasFlag(SyncOperation.All)) &&
d.SyncSide == syncSide &&
string.Equals(d.FieldNameToUpdate, fieldToUpdate, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception(string.Format("Field '{0}' already exists for operation '{1}' and sync side '{2}'.",
fieldToUpdate, Enum.GetName(typeof(SyncOperation), SyncOperation.Deletes), Enum.GetName(typeof(SyncSide), syncSide)));
}
switch (syncSide)
{
case SyncSide.Source:
if (!_addedSourceFields.Contains(fieldToUpdate, StringComparer.OrdinalIgnoreCase))
{
AddToSyncSideFieldsList(syncSide, fieldToUpdate);
}
break;
case SyncSide.Target:
if (!_addedTargetFields.Contains(fieldToUpdate, StringComparer.OrdinalIgnoreCase))
{
AddToSyncSideFieldsList(syncSide, fieldToUpdate);
}
break;
default:
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
_customSetFields.Add(new CustomSetField(syncSide, fieldToCompare, fieldToUpdate, customSetMethod, appliesTo, onlyApplyWithOtherChanges));
}
public List <DataSource> GetJobDataSourcesByJobId(Guid jobId, SyncSide syncSide)
{
try
{
return(configurator.GetJobDataSourcesByJobId(jobId, syncSide));
}
catch (Exception ex)
{
SyncEngineLogger.WriteExceptionToLog(ex, WEB_SERVICE_EXCEPTION_MESSAGE);
throw;
}
}
public bool JobDataSourceExists(Guid jobId, Guid dataSourceId, SyncSide syncSide)
{
try
{
return(configurator.JobDataSourceExists(jobId, dataSourceId, syncSide));
}
catch (Exception ex)
{
SyncEngineLogger.WriteExceptionToLog(ex, WEB_SERVICE_EXCEPTION_MESSAGE);
throw;
}
}
public JobDataSource(SyncSide syncSide, DataSource dataSource, RunHistory history)
{
if (dataSource == null)
{
throw new Exception("Data source can not be null.");
}
DataSource = dataSource;
SyncSide = syncSide;
History = history;
}
public JobBatch ProcessBatchByDataSourceId(Guid dataSourceId, SyncSide syncSide, List <EntityBatch> entityBatches)
{
try
{
var dataSource = GetDataSource(dataSourceId);
return(ProcessJobBatch(syncSide, dataSource, entityBatches));
}
catch (Exception ex)
{
SyncEngineLogger.WriteExceptionToLog(ex, WEB_SERVICE_EXCEPTION_MESSAGE);
throw;
}
}
public void DeleteJobDataSources(Guid jobId, SyncSide syncSide)
{
try
{
configurator.DeleteJobDataSources(jobId, syncSide);
scheduledJobManager.QueueScheduledJobs(clearExistingScheduledJobInstancesFromWaitingQueue: true);
}
catch (Exception ex)
{
SyncEngineLogger.WriteExceptionToLog(ex, WEB_SERVICE_EXCEPTION_MESSAGE);
throw;
}
}
private JobBatch ProcessJobBatch(SyncSide syncSide, DataSource dataSource, List <EntityBatch> entityBatches)
{
var jobDataSource = new JobDataSource(syncSide, dataSource);
var jobBatch = new JobBatch(syncSide, jobDataSource);
foreach (var entityBatch in entityBatches)
{
jobBatch.EntityBatches.Add(entityBatch);
}
dataSource.ProcessBatch(jobBatch);
return(jobBatch);
}
public static string GetDuplicateRowsExceptionMessage(SyncSide syncSide, string tableName, List <string> uniqueKeyColumnNames, HashSet <RecordKeyCombo> duplicateKeys)
{
if (uniqueKeyColumnNames.Count == 1)
{
return(string.Format("The {0}-side data with table name '{1}' has one or more duplicate key value(s) for column '{2}' and value(s): '{3}'.",
Enum.GetName(typeof(SyncSide), syncSide).ToLower(), tableName, uniqueKeyColumnNames[0],
StringHelper.GetDelimitedString(duplicateKeys.Select(d => d.Key1), "', '")));
}
else
{
return(string.Format("The {0}-side data with table name '{1}' has one or more duplicate key value(s) for columns '{2}' and value(s): ({3}).",
Enum.GetName(typeof(SyncSide), syncSide).ToLower(), tableName,
StringHelper.GetDelimitedString(uniqueKeyColumnNames),
StringHelper.GetDelimitedString(duplicateKeys, "), (")));
}
}
public JobFilter(SyncSide syncSide, string fieldName, JobFilterOperator @operator, object value, bool encloseValueInSingleQuotes = true)
{
if (String.IsNullOrWhiteSpace(fieldName))
{
throw new Exception("Field name is missing or empty.");
}
SyncSide = syncSide;
FieldName = fieldName;
Operator = @operator;
Value = value;
EncloseValueInSingleQuotes = encloseValueInSingleQuotes;
}
protected void AddToSyncSideFieldsList(SyncSide syncSide, string fieldName)
{
if (String.IsNullOrWhiteSpace(fieldName))
{
throw new Exception("Field name is missing or empty.");
}
fieldName = fieldName.Trim();
switch (syncSide)
{
case SyncSide.Source:
if (_addedSourceFields.Exists(d => d.Equals(fieldName, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception(string.Format("Source-side field already exists with name '{0}'.", fieldName));
}
else
{
_addedSourceFields.Add(fieldName.Trim());
}
break;
case SyncSide.Target:
if (_addedTargetFields.Exists(d => d.Equals(fieldName, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception(string.Format("Target-side field already exists with name '{0}'.", fieldName));
}
else
{
_addedTargetFields.Add(fieldName);
}
break;
default:
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
}
public CustomSetField(SyncSide syncSide, string fieldNameToCompare, string fieldNameToUpdate, Func <DataRow, Object> customSetMethod, SyncOperation appliesTo, bool onlyApplyWithOtherChanges = false)
{
if (String.IsNullOrWhiteSpace(fieldNameToCompare))
{
throw new Exception("Field name to compare is missing or empty.");
}
if (String.IsNullOrWhiteSpace(fieldNameToUpdate))
{
throw new Exception("Field name to update is missing or empty.");
}
if (customSetMethod == null)
{
throw new Exception("Custom method can not be null.");
}
SyncSide = syncSide;
FieldNameToCompare = fieldNameToCompare;
FieldNameToUpdate = fieldNameToUpdate;
if (SyncSide == Core.SyncSide.Source)
{
FieldNameToCompareWithPrefix = DataTableHelper.SOURCE_PREFIX + fieldNameToCompare;
FieldNameToUpdateWithPrefix = DataTableHelper.SOURCE_PREFIX + fieldNameToUpdate;
}
else
{
FieldNameToCompareWithPrefix = DataTableHelper.TARGET_PREFIX + fieldNameToCompare;
FieldNameToUpdateWithPrefix = DataTableHelper.TARGET_PREFIX + fieldNameToUpdate;
}
CustomSetMethod = customSetMethod;
AppliesTo = appliesTo;
OnlyApplyWithOtherChanges = onlyApplyWithOtherChanges;
}
private static EntityToUpdateDefinition GetEntityDefinition(DataMap map, SyncSide syncSide)
{
EntityToUpdateDefinition entityDefinition = null;
if (map is OneWayDataMap)
{
var oneWayMap = (OneWayDataMap)map;
entityDefinition = oneWayMap.EntityToUpdateDefinition;
}
else if (map is OneToMany_OneWayDataMap)
{
var oneToManyMap = (OneToMany_OneWayDataMap)map;
entityDefinition = oneToManyMap.EntityToUpdateDefinition;
}
else if (map is TwoWayDataMap)
{
var twoWayMap = (TwoWayDataMap)map;
if (syncSide == SyncSide.Source)
{
entityDefinition = twoWayMap.SourceDefinition;
}
else if (syncSide == SyncSide.Target)
{
entityDefinition = twoWayMap.TargetDefinition;
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
}
else
{
throw new DerivedClassNotImplementedException <OneToOneDataMap>(map);
}
return(entityDefinition);
}
public void AddDataSource(SyncSide syncSide, string name, Type adapterType, Dictionary <string, string> properties)
{
if (adapterType.BaseType != typeof(AdapterInstance))
{
throw new Exception(string.Format("Type '{0}' is not a valid adapter. Class must derive from base class '{1}'.",
adapterType.FullName, typeof(AdapterInstance).FullName));
}
var adapter = new Adapter(Guid.NewGuid(), adapterType.Name, adapterType.Assembly.Location, adapterType.FullName);
if (syncSide == SyncSide.Source)
{
if (_sourceSideDataSource != null)
{
throw new Exception("A source-side data source already exists.");
}
else
{
_sourceSideDataSource = new DataSource(Guid.NewGuid(), name, adapter);
_sourceSideDataSource.ExtendedProperties = properties;
}
}
else if (syncSide == SyncSide.Target)
{
if (_targetSideDataSource != null)
{
throw new Exception("A target-side data source already exists.");
}
else
{
_targetSideDataSource = new DataSource(Guid.NewGuid(), name, adapter);
_targetSideDataSource.ExtendedProperties = properties;
}
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
}
public void AddDataSource(DataSource dataSource, SyncSide side)
{
switch (side)
{
case SyncSide.Source:
if (dataSource == null)
{
throw new Exception("Source-side data source can not be null.");
}
else if (SourceDataSources.Keys.Where(d => d.ToLower() == dataSource.Name.ToLower()).Count() > 0)
{
throw new Exception(string.Format("A source-side data source with name '{0}' already exists.", dataSource.Name));
}
else
{
_sourceDataSources.Add(dataSource.Name, dataSource);
}
break;
case SyncSide.Target:
if (dataSource == null)
{
throw new Exception("Target-side data source can not be null.");
}
else
{
_targetDataSource = dataSource;
}
break;
default:
throw new EnumValueNotImplementedException <SyncSide>(side);
}
}
public static bool AreEqual(string fieldToUpdate, string sourceValue, string targetValue, FieldMap fieldMap, SyncSide syncSideToUpdate, ref string newValue)
{
string oldValue;
if (syncSideToUpdate == SyncSide.Target)
{
newValue = fieldMap.GetMappedValueWithExceptionThrower(fieldToUpdate, syncSideToUpdate, sourceValue, targetValue);
oldValue = targetValue;
}
else
{
newValue = fieldMap.GetMappedValueWithExceptionThrower(fieldToUpdate, syncSideToUpdate, targetValue, sourceValue);
oldValue = sourceValue;
}
if (oldValue == newValue)
{
return(true);
}
else
{
return(false);
}
}
private static object[] GetKeyValues(DataRow row, JoinFieldCollection joinKeysCollection, SyncSide syncSide, string joinSidePrefix)
{
var keyValues = new object[joinKeysCollection.Count];
for (int i = 0; i < joinKeysCollection.Count; i++)
{
if (syncSide == SyncSide.Source)
{
keyValues[i] = row[joinSidePrefix + joinKeysCollection.JoinFields[i].SourceJoinField];
}
else if (syncSide == SyncSide.Target)
{
keyValues[i] = row[joinSidePrefix + joinKeysCollection.JoinFields[i].TargetJoinField];
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
}
return(keyValues);
}
private static void SetCombinedPrimaryKeys(DataTable combinedTable, JoinFieldCollection joinKeysCollection, SyncSide syncSide, string joinSidePrefix)
{
var combinedJoinKeys = new DataColumn[joinKeysCollection.Count];
for (int i = 0; i < joinKeysCollection.Count; i++)
{
if (syncSide == SyncSide.Source)
{
combinedJoinKeys[i] = combinedTable.Columns[joinSidePrefix + joinKeysCollection.JoinFields[i].SourceJoinField];
}
else if (syncSide == SyncSide.Target)
{
combinedJoinKeys[i] = combinedTable.Columns[joinSidePrefix + joinKeysCollection.JoinFields[i].TargetJoinField];
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
}
try
{
combinedTable.PrimaryKey = combinedJoinKeys;
}
catch (Exception ex)
{
throw new Exception(string.Format("The {0}-side data has one or more duplicate primary key value(s) for column(s) '{1}'.",
Enum.GetName(typeof(SyncSide), syncSide).ToLower(),
StringHelper.GetDelimitedString(joinKeysCollection.JoinFields.Select(d => d.SourceJoinField))), ex);
}
// set the key to allow Nulls (otherwise, inserting target data w/o a matching source record will error)
foreach (DataColumn col in combinedTable.PrimaryKey)
{
col.AllowDBNull = true;
}
}
public void AddAutoSetField(SyncSide syncSide, string fieldToCompare, string fieldToUpdate, object value, SyncOperation appliesTo, bool onlyApplyWithOtherChanges = false)
{
base.AddCustomSetField(syncSide, fieldToCompare, fieldToUpdate, (row) => { return(value); }, appliesTo, onlyApplyWithOtherChanges);
}
public EntityToUpdateDefinition(SyncSide syncSide, string technicalEntityName, List <string> primaryKeyColumnNames, PrimaryKeyGenerationType primaryKeyGenerationType, object customCommand)
{
SyncSide = syncSide;
if (!(primaryKeyGenerationType == Data.PrimaryKeyGenerationType.AutoGenerate ||
primaryKeyGenerationType == Data.PrimaryKeyGenerationType.Manual ||
primaryKeyGenerationType == Data.PrimaryKeyGenerationType.Custom))
{
throw new EnumValueNotImplementedException <PrimaryKeyGenerationType>(primaryKeyGenerationType);
}
if (primaryKeyColumnNames == null || primaryKeyColumnNames.Count == 0)
{
throw new Exception("One or more primary key columns names are required.");
}
foreach (var primaryKeyColumnName in primaryKeyColumnNames)
{
if (String.IsNullOrWhiteSpace(primaryKeyColumnName))
{
throw new Exception("Primary key column name is missing or empty.");
}
}
TechnicalEntityName = technicalEntityName.Trim();
primaryKeyColumnNames.ForEach(d => d.Trim());
PrimaryKeyColumnNames = primaryKeyColumnNames;
PrimaryKeyGenerationType = primaryKeyGenerationType;
CustomCommand = customCommand;
if (PrimaryKeyGenerationType == PrimaryKeyGenerationType.Manual)
{
foreach (var primaryKeyColumnName in PrimaryKeyColumnNames)
{
DataOnlyFields.Add(new DataOnlyField(primaryKeyColumnName));
}
}
switch (syncSide)
{
case SyncSide.Source:
foreach (var primaryKeyColumnName in PrimaryKeyColumnNames)
{
PrimaryKeyColumnNamesWithPrefix.Add(DataTableHelper.SOURCE_PREFIX + primaryKeyColumnName);
}
break;
case SyncSide.Target:
foreach (var primaryKeyColumnName in PrimaryKeyColumnNames)
{
PrimaryKeyColumnNamesWithPrefix.Add(DataTableHelper.TARGET_PREFIX + primaryKeyColumnName);
}
break;
default:
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
// validate added secondary key and add as data only field
SecondaryKeyColumnNames.ListChanged += new ListChangedEventHandler((sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
if (String.IsNullOrWhiteSpace(SecondaryKeyColumnNames[args.NewIndex]))
{
throw new Exception("Secondary key column name is missing or empty.");
}
DataOnlyFields.Add(new DataOnlyField(SecondaryKeyColumnNames[args.NewIndex], false));
}
});
// validate added data only field
DataOnlyFields.ListChanged += new ListChangedEventHandler((sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
if (String.IsNullOrWhiteSpace(DataOnlyFields[args.NewIndex].FieldName))
{
throw new Exception("Data only field name is missing or empty.");
}
// remove if a duplicate value
if (DataOnlyFields.Where(d => d.FieldName.Equals(DataOnlyFields[args.NewIndex].FieldName, StringComparison.OrdinalIgnoreCase)).Count() > 1)
{
var newItem = DataOnlyFields[args.NewIndex];
var existingItem = DataOnlyFields.Where(d => d.FieldName.Equals(DataOnlyFields[args.NewIndex].FieldName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// override the mapped field if a Func is specified to populate the value
if (existingItem.MethodToPopulateValue != null && newItem.MethodToPopulateValue == null)
{
newItem.MethodToPopulateValue = existingItem.MethodToPopulateValue;
}
if (existingItem.IsRequiredByJobBatch)
{
newItem.IsRequiredByJobBatch = true;
}
// remove the old instance now that the new one is updated
DataOnlyFields.Remove(existingItem);
}
}
});
// validate added data only field
TransposeDataOnlyFields.ListChanged += new ListChangedEventHandler((sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
if (String.IsNullOrWhiteSpace(TransposeDataOnlyFields[args.NewIndex].FieldName))
{
throw new Exception("Transpose data only field name is missing or empty.");
}
// remove if a duplicate value
if (TransposeDataOnlyFields.Where(d => d.FieldName.Equals(TransposeDataOnlyFields[args.NewIndex].FieldName, StringComparison.OrdinalIgnoreCase)).Count() > 1)
{
var newItem = DataOnlyFields[args.NewIndex];
var existingItem = TransposeDataOnlyFields.Where(d => d.FieldName.Equals(TransposeDataOnlyFields[args.NewIndex].FieldName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
// remove the old instance now that the new one is updated
TransposeDataOnlyFields.Remove(existingItem);
}
}
});
}
public EntityToUpdateDefinition(SyncSide syncSide, string technicalEntityName, string primaryKeyColumnName, PrimaryKeyGenerationType primaryKeyGenerationType, object customCommand)
: this(syncSide, technicalEntityName, new List <string> {
primaryKeyColumnName
}, primaryKeyGenerationType, customCommand)
{
}
public EntityToUpdateDefinition(SyncSide syncSide, string technicalEntityName, List <string> primaryKeyColumnNames, object customCommand)
: this(syncSide, technicalEntityName, primaryKeyColumnNames, PrimaryKeyGenerationType.Custom, customCommand)
{
}
public EntityToUpdateDefinition(SyncSide syncSide, string technicalEntityName, List <string> primaryKeyColumnNames, PrimaryKeyGenerationType primaryKeyGenerationType)
: this(syncSide, technicalEntityName, primaryKeyColumnNames, primaryKeyGenerationType, null)
{
}
public EntityToUpdateDefinition(SyncSide syncSide, string technicalEntityName, string primaryKeyColumnName)
: this(syncSide, technicalEntityName, primaryKeyColumnName, PrimaryKeyGenerationType.Manual)
{
}
public override HashSet <string> GetMappedDataFieldNames(SyncSide syncSide, DataMapFieldType includedFieldTypes = DataMapFieldType.All, string prefix = "")
{
HashSet <string> dataFields = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
if (syncSide == SyncSide.Source)
{
if (includedFieldTypes.HasFlag(DataMapFieldType.PrimaryKey) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var primaryKey in SourceDefinition.PrimaryKeyColumnNames)
{
dataFields.Add(prefix + primaryKey);
}
}
if (includedFieldTypes.HasFlag(DataMapFieldType.SecondaryKey) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var secondaryKey in SourceDefinition.SecondaryKeyColumnNames)
{
dataFields.Add(prefix + secondaryKey);
}
}
if (includedFieldTypes.HasFlag(DataMapFieldType.CompareField) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var compareField in CompareFields)
{
dataFields.Add(prefix + compareField.SourceFieldToCompare);
}
}
if (includedFieldTypes.HasFlag(DataMapFieldType.DataOnlyField) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var dataOnlyField in SourceDefinition.DataOnlyFields)
{
dataFields.Add(prefix + dataOnlyField.FieldName);
}
}
}
else if (syncSide == SyncSide.Target)
{
if (includedFieldTypes.HasFlag(DataMapFieldType.PrimaryKey) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var primaryKey in TargetDefinition.PrimaryKeyColumnNames)
{
dataFields.Add(prefix + primaryKey);
}
}
if (includedFieldTypes.HasFlag(DataMapFieldType.SecondaryKey) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var secondaryKey in TargetDefinition.SecondaryKeyColumnNames)
{
dataFields.Add(prefix + secondaryKey);
}
}
if (includedFieldTypes.HasFlag(DataMapFieldType.CompareField) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var compareField in CompareFields)
{
dataFields.Add(prefix + compareField.TargetFieldToCompare);
}
}
if (includedFieldTypes.HasFlag(DataMapFieldType.DataOnlyField) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var dataOnlyField in TargetDefinition.DataOnlyFields)
{
dataFields.Add(prefix + dataOnlyField.FieldName);
}
}
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSide);
}
if (includedFieldTypes.HasFlag(DataMapFieldType.CustomSetField) || includedFieldTypes.HasFlag(DataMapFieldType.All))
{
foreach (var customSetField in CustomSetFields.Where(d => d.SyncSide == syncSide))
{
dataFields.Add(prefix + customSetField.FieldNameToCompare);
}
}
return(dataFields);
}
public List <DataSource> GetJobDataSourcesByJobName(string integrationName, string jobName, SyncSide syncSide)
{
try
{
return(configurator.GetJobDataSourcesByJobName(integrationName, jobName, syncSide));
}
catch (Exception ex)
{
SyncEngineLogger.WriteExceptionToLog(ex, WEB_SERVICE_EXCEPTION_MESSAGE);
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="sourceValue"></param>
/// <param name="targetValue"></param>
/// <param name="syncDirection"></param>
/// <returns>Returns the new value. The return value will be equal to the old value if no changes were applied.</returns>
public string GetMappedValue(string sourceValue, string targetValue, SyncSide syncSideToUpdate)
{
if (sourceValue != null)
{
sourceValue = sourceValue.Trim();
}
if (targetValue != null)
{
targetValue = targetValue.Trim();
}
foreach (FieldMapPair fmp in Maps)
{
if (syncSideToUpdate == SyncSide.Target)
{
if (string.Equals(sourceValue, fmp.SourceValue, ComparisonType))
{
return(GetAppliedFieldMapValue(targetValue, fmp.TargetValue));
}
}
else if (syncSideToUpdate == SyncSide.Source)
{
if (string.Equals(targetValue, fmp.TargetValue, ComparisonType))
{
return(GetAppliedFieldMapValue(sourceValue, fmp.SourceValue));
}
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSideToUpdate);
}
}
if (syncSideToUpdate == SyncSide.Target)
{
// the source value was not found in the fied map, so apply unmapped behavior
switch (TargetSideUnmappedValueBehavior)
{
case UnmappedValueBehavior.DoNotUpdate:
// As DoNotUpdate is configured, return the old target value if the source key wasn't found
return(targetValue);
case UnmappedValueBehavior.PassThrough:
// if the source value wasn't found in the map, "pass through" the source value to target as is
return(sourceValue);
case UnmappedValueBehavior.UseDefaultValue:
// if the source value wasn't found in the map, return the configured default value
return(TargetSideDefaultValue);
case UnmappedValueBehavior.ThrowException:
throw new UnmappedValueException(SyncDirection.SourceToTarget, sourceValue);
default:
throw new EnumValueNotImplementedException <UnmappedValueBehavior>(TargetSideUnmappedValueBehavior);
}
}
else if (syncSideToUpdate == SyncSide.Source)
{
// the source value was not found in the fied map, so apply unmapped behavior
switch (SourceSideUnmappedValueBehavior)
{
case UnmappedValueBehavior.DoNotUpdate:
// As DoNotUpdate is configured, return the old target value if the source key wasn't found
return(sourceValue);
case UnmappedValueBehavior.PassThrough:
// if the source value wasn't found in the map, "pass through" the source value to target as is
return(targetValue);
case UnmappedValueBehavior.UseDefaultValue:
// if the source value wasn't found in the map, return the configured default value
return(SourceSideDefaultValue);
case UnmappedValueBehavior.ThrowException:
throw new UnmappedValueException(SyncDirection.TargetToSource, targetValue);
default:
throw new EnumValueNotImplementedException <UnmappedValueBehavior>(TargetSideUnmappedValueBehavior);
}
}
else
{
throw new EnumValueNotImplementedException <SyncSide>(syncSideToUpdate);
}
}
public abstract HashSet <string> GetMappedDataFieldNames(SyncSide syncSide, DataMapFieldType includedFieldTypes, string prefix = "");
