/// <summary>
/// Method: Update
/// Description: It is used to update DeDupSettings by ccid in DeDupSettings table
/// </summary>
/// <param name="item"></param>
public void Update(DeDupSettings item)
{
//Get DeDupSettings by ccid
var entity = Find(item.ccid);
if (entity != null)
{
entity.database_config_json = item.database_config_json;
_context.Entry(entity).State = EntityState.Modified;
_context.SaveChanges();
}
}
/// <summary>
/// Method: AddEditDatabaseConfig
/// Description: It is used to insert/update database config by ccid
/// </summary>
/// <param name="databaseSetting"></param>
public void AddEditDatabaseConfig(DatabaseConfig databaseSetting)
{
//Get DeDupSettings by ccid
var entity = Find(databaseSetting.ccid);
var isNew = false;
if (entity == null)
{
isNew = true;
//Create new DeDupSettings and assign ccid
entity = new DeDupSettings()
{
ccid = databaseSetting.ccid
};
}
List <DatabaseConfig> dbConfigs = entity.ToModel <List <DatabaseConfig> >();
if (dbConfigs != null && dbConfigs.FirstOrDefault(p => p.databaseType == databaseSetting.databaseType) != null)
{
dbConfigs.FirstOrDefault(p => p.databaseType == databaseSetting.databaseType).syncDefaultDatabaseUrl = databaseSetting.syncDefaultDatabaseUrl;
// dbConfigs.FirstOrDefault(p => p.databaseType == databaseSetting.databaseType).syncFollowerDatabaseUrl = databaseSetting.syncFollowerDatabaseUrl;
}
else
{
if (dbConfigs == null)
{
dbConfigs = new List <DatabaseConfig>();
}
dbConfigs.Add(databaseSetting);
}
//Assign database config as json
entity.database_config_json = JsonConvert.SerializeObject(dbConfigs);
//Add/Update DeDupSettings entity
if (isNew)
{
_context.DeDupSettings.Add(entity);
}
else
{
_context.Entry(entity).State = EntityState.Modified;
}
_context.SaveChanges();
}
//public ConnectorsRepository()
//{
// _context = (DeDupContext)Utilities.AppServiceProvider.GetService(typeof(DeDupContext));
//}
/// <summary>
/// Method: GetMaxID
/// Description: It is used to get max of connector id in connectors table by ccid
/// </summary>
/// <param name="ccid"></param>
/// <param name="dedupSettings"></param>
/// <returns>max connector id as int</returns>
private int GetMaxID(string ccid, ref DeDupSettings dedupSettings)
{
int connectorId = 0;
if (_context.Connectors.Where(r => r.ccid == ccid).Count() > 0)
{
var entity = _context.Connectors.Where(r => r.ccid == ccid).OrderByDescending(r => r.connector_id).FirstOrDefault();
_context.Entry(entity).Reference(e => e.DeDupSetting).Load();
dedupSettings = entity.DeDupSetting;
connectorId = entity.connector_id;
}
else if (_context.DeDupSettings.FirstOrDefault(r => r.ccid == ccid) != null)
{
dedupSettings = _context.DeDupSettings.FirstOrDefault(r => r.ccid == ccid);
}
return(connectorId);
}
/// <summary>
/// Method: AddEditDatabaseConfig
/// Description: It is used to insert/update database config property by ccid
/// </summary>
/// <param name="ccid"></param>
/// <param name="fieldName"></param>
/// <param name="fieldValue"></param>
public void AddEditDatabaseConfig(string ccid, string fieldName, string fieldValue)
{
var isNew = false;
//Get DeDupSettings by ccid
var entity = Find(ccid);
//Get DatabaseConfig by ccid
var dbConfig = entity.ToModel <DatabaseConfig>(ccid);
if (entity == null)
{
isNew = true;
//Create new DeDupSettings and assign ccid
entity = new DeDupSettings()
{
ccid = ccid
};
}
//Update DatabaseConfig property value by name
if (dbConfig != null && dbConfig.GetType().GetProperty(fieldName) != null)
{
var propertyInfo = dbConfig.GetType().GetProperty(fieldName);
propertyInfo.SetValue(dbConfig, fieldValue, null);
}
//Assign database config as json
entity.database_config_json = JsonConvert.SerializeObject(dbConfig);
//Add/Update DeDupSettings entity
if (isNew)
{
_context.DeDupSettings.Add(entity);
}
else
{
_context.Entry(entity).State = EntityState.Modified;
}
_context.SaveChanges();
}
/// <summary>
/// Method: AddEditDatabaseConfig
/// Description: It is used to insert/update database config property by ccid
/// </summary>
/// <param name="ccid"></param>
/// <param name="fieldName"></param>
/// <param name="fieldValue"></param>
public void AddEditDatabaseConfig(DatabaseConfig dbConfig, int?id)
{
DeDupSettings dedupSettings = null;
if (dbConfig.databaseType == DatabaseType.None)
{
dbConfig.databaseType = DatabaseType.Heroku_Postgres;
}
if (id.HasValue)
{
//get connector by id
Connectors entity = Find(dbConfig.ccid, id);
//assign DeDupsettings
dedupSettings = entity.DeDupSetting;
//save sync db config
if (dedupSettings != null && string.IsNullOrEmpty(dedupSettings.database_config_json))
{
dedupSettings.database_config_json = JsonConvert.SerializeObject(dbConfig);
_context.Entry(dedupSettings).State = EntityState.Modified;
}
if (entity.sync_src == DataSource.Heroku_Postgres ||
entity.sync_src == DataSource.Azure_Postgres ||
entity.sync_src == DataSource.AWS_Postgres ||
entity.sync_src == DataSource.Azure_SQL)
{
entity.src_config_json = JsonConvert.SerializeObject((new List <DatabaseConfig>()
{
dbConfig
}));
}
if (entity.connector_type == ConnectorType.Heroku_Postgres ||
entity.connector_type == ConnectorType.Azure_Postgres ||
entity.connector_type == ConnectorType.AWS_Postgres ||
entity.connector_type == ConnectorType.Azure_SQL)
{
entity.dest_config_json = JsonConvert.SerializeObject((new List <DatabaseConfig>()
{
dbConfig
}));
}
_context.Entry(entity).State = EntityState.Modified;
}
else
{
if (_context.DeDupSettings.Where(r => r.ccid == dbConfig.ccid).Count() > 0)
{
dedupSettings = _context.DeDupSettings.Where(r => r.ccid == dbConfig.ccid).FirstOrDefault();
//get latest database value
_context.Entry <DeDupSettings>(dedupSettings).GetDatabaseValues();
dedupSettings.database_config_json = JsonConvert.SerializeObject(dbConfig);
_context.Entry(dedupSettings).State = EntityState.Modified;
}
else
{
//Create new DeDupSettings and assign ccid
dedupSettings = new DeDupSettings()
{
ccid = dbConfig.ccid
};
dedupSettings.database_config_json = JsonConvert.SerializeObject((new List <DatabaseConfig>()
{
dbConfig
}));
_context.DeDupSettings.Add(dedupSettings);
}
}
_context.SaveChanges();
}
/// <summary>
/// Method: AddEditExtensionsConfig
/// Description: It is used to add/update connector in connectors table
/// </summary>
/// <param name="connectorConfig"></param>
public void AddEditExtensionsConfig(ConnectorConfig connectorConfig)
{
using (var transaction = _context.Database.BeginTransaction())
{
Connectors entity;
DeDupSettings dedupSettings = null;
bool isNew = false;
int isSyncTableExist = 0;
int isSyncGoldenTableExist = 0;
if (connectorConfig.connectorId.HasValue)
{
entity = Find(connectorConfig.ccid, connectorConfig.connectorId);
if (entity != null)
{
//delete sync process if it is in progress while updating connector
if (!string.IsNullOrEmpty(entity.job_id) ||
entity.schedule_type != ScheduleType.MANUAL_SYNC)
{
//delete old jobs
JobScheduler.Instance.DeleteJob(ccid: entity.ccid, connectorId: entity.connector_id, jobId: entity.job_id, scheduleType: entity.schedule_type);
//reset job id once deleted
entity.job_id = string.Empty;
if (entity.sync_status == 1)
{
//set status interrupted
entity.sync_status = 10;
}
else if (entity.sync_status.HasValue)
{
//reset sync status
entity.sync_status = 0;
}
}
else if (entity.sync_status.HasValue)
{
//reset sync status
entity.sync_status = 0;
}
if (entity.sync_status != 2 && entity.sync_status != 10)
{
entity.sync_count = null;
entity.unique_records_count = null;
entity.sync_updated_count = null;
entity.total_records_count = null;
entity.sync_log_json = null;
entity.sync_started_at = null;
entity.sync_ended_at = null;
entity.last_sync_at = null;
entity.last_sync_status = null;
}
dedupSettings = entity.DeDupSetting;
//check table exist or not. if not then create table and sync
isSyncTableExist = SyncRepository.SyncTableIsExist(connectorConfig);
isSyncGoldenTableExist = SyncRepository.SyncGoldenTableIsExist(connectorConfig);
}
}
else
{
isNew = true;
entity = new Connectors()
{
ccid = connectorConfig.ccid
};
//Set next connector id
entity.connector_id = GetMaxID(entity.ccid, ref dedupSettings) + 1;
}
entity.connector_name = connectorConfig.connectorName;
if (isNew)
{
entity.sync_src = connectorConfig.dataSource;
entity.src_object_name = connectorConfig.sourceObjectName;
//commented by Kathir on 12-Aug-2020
// entity.src_object_fields_json = JsonConvert.SerializeObject(connectorConfig.sourceObjectFields);
if (entity.sync_src == DataSource.Heroku_Postgres ||
entity.sync_src == DataSource.Azure_Postgres ||
entity.sync_src == DataSource.AWS_Postgres ||
entity.sync_src == DataSource.Azure_SQL)
{
entity.src_config_json = JsonConvert.SerializeObject(connectorConfig.dbConfig);
}
if (connectorConfig.dedup_type != DedupType.Full_Dedup)
{
entity.connector_type = (ConnectorType)connectorConfig.syncDestination;
entity.dest_object_name = connectorConfig.destObjectName;
}
else
{
if (connectorConfig.dataSource == DataSource.Heroku_Postgres)
{
entity.connector_type = ConnectorType.Heroku_Postgres;
}
if (connectorConfig.dataSource == DataSource.AWS_Postgres)
{
entity.connector_type = ConnectorType.AWS_Postgres;
}
if (connectorConfig.dataSource == DataSource.Azure_Postgres)
{
entity.connector_type = ConnectorType.Azure_Postgres;
}
entity.dest_object_name = string.Empty;
}
entity.src_schema = connectorConfig.dbSchema;
entity.dedup_type = connectorConfig.dedup_type;
entity.dedup_source_type = connectorConfig.dedupSourceType;
if ((connectorConfig.dedupSourceType == SourceType.Copy_Source_data_to_Destination_and_Remove_Duplicates_from_Destination || connectorConfig.dedupSourceType == SourceType.Merge_Table_A_Data_to_Table_B_and_Remove_Duplicates_from_Table_B))
{
entity.compare_object_fields = JsonConvert.SerializeObject(connectorConfig.compareObjectFieldsMapping);
entity.compare_config_json = JsonConvert.SerializeObject(connectorConfig.dbConfig_compare);
}
//if (IsMultipleConfigSupported)
{
if (entity.connector_type == ConnectorType.Heroku_Postgres ||
entity.connector_type == ConnectorType.Azure_Postgres ||
entity.connector_type == ConnectorType.AWS_Postgres ||
entity.connector_type == ConnectorType.Azure_SQL)
{
entity.dest_config_json = JsonConvert.SerializeObject(connectorConfig.destDBConfig);
}
}
//set global db setting
if (dedupSettings != null)
{
//save sync database url
if (connectorConfig.dbConfig != null &&
!string.IsNullOrEmpty(connectorConfig.dbConfig.syncDefaultDatabaseUrl))
{
if (string.IsNullOrEmpty(dedupSettings.database_config_json))
{
dedupSettings.database_config_json = JsonConvert.SerializeObject((new List <DatabaseConfig>()
{
connectorConfig.dbConfig
}));
_context.Entry(dedupSettings).State = EntityState.Modified;
}
else
{
var dbConfigs = dedupSettings.ToModel <List <DatabaseConfig> >();
if (dbConfigs != null && dbConfigs.FirstOrDefault(p => p.databaseType == connectorConfig.dbConfig.databaseType) == null)
{
dbConfigs.Add(connectorConfig.dbConfig);
dedupSettings.database_config_json = JsonConvert.SerializeObject(dbConfigs);
_context.Entry(dedupSettings).State = EntityState.Modified;
}
}
}
}
else
{
dedupSettings = new DeDupSettings()
{
ccid = connectorConfig.ccid
};
//save sync database url
if (connectorConfig.dbConfig != null && !string.IsNullOrEmpty(connectorConfig.dbConfig.syncDefaultDatabaseUrl))
{
dedupSettings.database_config_json = JsonConvert.SerializeObject((new List <DatabaseConfig>()
{
connectorConfig.dbConfig
}));
}
//add dedupsetting
_context.Entry(dedupSettings).State = EntityState.Added;
}
entity.unique_records_count = null;
entity.sync_updated_count = null;
entity.sync_count = null;
entity.total_records_count = null;
}
entity.schedule_type = connectorConfig.scheduleType;
entity.src_new_record_filter = connectorConfig.srcNewRecordFilter;
entity.src_update_record_filter = connectorConfig.srcUpdateRecordFilter;
entity.two_way_sync_priority = connectorConfig.twoWaySyncPriority;
entity.dest_schema = connectorConfig.destDBSchema;
entity.custom_schedule_in_minutes = connectorConfig.customScheduleInMinutes;
//Added by Kathir on 20-8-2020
entity.dedup_method = connectorConfig.dedup_method;
//if (connectorConfig.dedup_method == SimilarityType.Fuzzy_Compare)
//{
// entity.fuzzy_ratio = connectorConfig.fuzzy_ratio;
//}
entity.fuzzy_ratio = connectorConfig.fuzzy_ratio;
entity.review_before_delete = connectorConfig.review_before_delete;
entity.backup_before_delete = connectorConfig.backup_before_delete;
if (connectorConfig.dedup_type == DedupType.Full_Dedup)
{
entity.simulation_count = -1;
}
else
{
entity.simulation_count = connectorConfig.simulation_count;
}
if (string.IsNullOrEmpty(entity.src_object_name))
{
entity.src_object_name = connectorConfig.sourceObjectName;
}
if ((connectorConfig.dedupSourceType == SourceType.Copy_Source_data_to_Destination_and_Remove_Duplicates_from_Destination || connectorConfig.dedupSourceType == SourceType.Merge_Table_A_Data_to_Table_B_and_Remove_Duplicates_from_Table_B))
{
//entity.compare_object_fields = JsonConvert.SerializeObject(connectorConfig.compareObjectFieldsMapping);
entity.compare_config_json = JsonConvert.SerializeObject(connectorConfig.dbConfig_compare);
}
//commented by Kathir on 12-Aug-2020
//if (string.IsNullOrEmpty(entity.src_object_fields_json))
//{
// entity.src_object_fields_json = JsonConvert.SerializeObject(connectorConfig.sourceObjectFields);
//}
if (string.IsNullOrEmpty(entity.dest_object_name))
{
if (connectorConfig.dedup_type == DedupType.Full_Dedup && connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table)
{
entity.dest_object_name = connectorConfig.sourceObjectName;
}
else if (connectorConfig.dedup_type == DedupType.Full_Dedup && (connectorConfig.dedupSourceType == SourceType.Copy_Source_data_to_Destination_and_Remove_Duplicates_from_Destination || connectorConfig.dedupSourceType == SourceType.Merge_Table_A_Data_to_Table_B_and_Remove_Duplicates_from_Table_B))
{
entity.dest_object_name = (connectorConfig.dbConfig_compare.table_type == SelectedTableType.Create_New_Table ? connectorConfig.dbConfig_compare.new_table_name : connectorConfig.dbConfig_compare.object_name);
}
else
{
entity.dest_object_name = connectorConfig.destObjectName;
}
}
//Assigned source object fields to compare object field json
entity.compare_object_fields = JsonConvert.SerializeObject(connectorConfig.sourceObjectFields);
//if (connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table)
//{
// if (connectorConfig.sourceObjectFields != null && connectorConfig.sourceObjectFields.Count > 0)
// {
// foreach (string sel_fields in connectorConfig.sourceObjectFields)
// {
// connectorConfig.compareObjectFieldsMapping.Add(new KeyValuePair<string, string>(sel_fields, sel_fields));
// }
// }
// entity.compare_object_fields = JsonConvert.SerializeObject(connectorConfig.sourceObjectFields);
//}
if (connectorConfig.dedup_type == DedupType.Full_Dedup)
{
entity.dest_object_name = (connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table ? connectorConfig.sourceObjectName : (connectorConfig.dbConfig_compare.table_type == SelectedTableType.Create_New_Table ? connectorConfig.dbConfig_compare.new_table_name : connectorConfig.dbConfig_compare.object_name));
connectorConfig.destDBConfig.syncDefaultDatabaseUrl = (connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table ? connectorConfig.dbConfig.syncDefaultDatabaseUrl : connectorConfig.dbConfig_compare.syncDefaultDatabaseUrl);
connectorConfig.destDBConfig.databaseType = (connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table ? connectorConfig.dbConfig.databaseType : connectorConfig.dbConfig_compare.databaseType);
connectorConfig.destDBConfig.dataSource = (connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table ? connectorConfig.dbConfig.dataSource : connectorConfig.dbConfig_compare.dataSource);
entity.dest_config_json = JsonConvert.SerializeObject(connectorConfig.destDBConfig);
entity.dest_schema = (connectorConfig.dedupSourceType == SourceType.Remove_Duplicates_from_a_Single_Table ? connectorConfig.dbSchema : connectorConfig.dbConfig_compare.db_schema);
}
//save extension setting
_context.Entry(entity).State = isNew ? EntityState.Added : EntityState.Modified;
_context.SaveChanges();
//if (isSyncTableExist == 0 && connectorConfig.dedup_type != DedupType.Full_Dedup)
//{
// var errorMessage = string.Empty;
// if (connectorConfig.syncDestination == ConnectorType.Heroku_Postgres
// || connectorConfig.syncDestination == ConnectorType.Azure_Postgres
// || connectorConfig.syncDestination == ConnectorType.AWS_Postgres)
// {
// var dbStatus = SyncRepository.CreatePostgresTable(connectorConfig, out errorMessage);
// if (dbStatus == -1)
// {
// transaction.Rollback();
// throw new Exception(message: (string.IsNullOrEmpty(errorMessage) ? "Not able to create postgres table." : errorMessage)) { };
// }
// else if (dbStatus == 2)
// {
// transaction.Rollback();
// throw new Exception(message: "The " + connectorConfig.destObjectName + " postgres table already exists.") { };
// }
// }
//}
//if (isSyncGoldenTableExist == 0 && connectorConfig.dbConfig_compare.table_type == SelectedTableType.Create_New_Table)
//{
// var errorMessage = string.Empty;
// if (connectorConfig.dbConfig_compare.dataSource == DataSource.Heroku_Postgres
// || connectorConfig.dbConfig_compare.dataSource == DataSource.Azure_Postgres
// || connectorConfig.dbConfig_compare.dataSource == DataSource.AWS_Postgres)
// {
// var dbStatus = SyncRepository.CreatePostgresGoldenTable(connectorConfig, out errorMessage);
// if (dbStatus == -1)
// {
// transaction.Rollback();
// throw new Exception(message: (string.IsNullOrEmpty(errorMessage) ? "Not able to create postgres table." : errorMessage)) { };
// }
// else if (dbStatus == 2)
// {
// transaction.Rollback();
// throw new Exception(message: "The " + connectorConfig.dbConfig_compare.new_table_name + " postgres table already exists.") { };
// }
// }
//}
transaction.Commit();
//Schedule job if scheduletype is not manual
if (entity.schedule_type != ScheduleType.MANUAL_SYNC)
{
if (entity.schedule_type == ScheduleType.CUSTOM)
{
JobScheduler.Instance.ScheduleJob(entity.ccid, entity.connector_id, entity.connector_type, entity.schedule_type, (entity.custom_schedule_in_minutes.HasValue ? entity.custom_schedule_in_minutes.Value : 1200));
}
else
{
JobScheduler.Instance.ScheduleJob(entity.ccid, entity.connector_id, entity.connector_type, entity.schedule_type);
}
}
//});
}
}
public static T ToModel <T>(this List <Connectors> connectors, bool isSetConfig = true) where T : class
{
if (typeof(T) == typeof(List <ConnectorConfig>))
{
List <ConnectorConfig> connectorConfigs = null;
if (connectors != null)
{
DeDupSettings dedupSettings = isSetConfig ? connectors.FirstOrDefault().DeDupSetting : null;
connectorConfigs = connectors.Select(c =>
{
ConnectorConfig conConfig;
conConfig = new ConnectorConfig()
{
ccid = c.ccid,
connectorId = c.connector_id,
connectorName = c.connector_name,
sourceObjectName = c.src_object_name,
destObjectName = c.dest_object_name,
scheduleType = c.schedule_type,
srcNewRecordFilter = c.src_new_record_filter,
srcUpdateRecordFilter = c.src_update_record_filter,
twoWaySyncPriority = c.two_way_sync_priority,
syncDestination = c.connector_type,
syncCount = c.sync_count,
syncStatus = c.sync_status,
dedup_type = c.dedup_type,
jobId = c.job_id,
syncStartedAt = c.sync_started_at,
syncEndedAt = c.sync_ended_at,
lastSyncAt = c.last_sync_at,
lastSyncStatus = c.last_sync_status,
dbSchema = c.src_schema,
dataSource = c.sync_src,
destDBSchema = c.dest_schema,
customScheduleInMinutes = c.custom_schedule_in_minutes,
dedupSourceType = c.dedup_source_type,
dedup_method = c.dedup_method,
review_before_delete = c.review_before_delete,
backup_before_delete = c.backup_before_delete,
simulation_count = c.simulation_count,
total_records_count = c.total_records_count,
deduped_count = c.deduped_count,
fuzzy_ratio = c.fuzzy_ratio * 100,
unique_records_count = c.unique_records_count
};
//if (!string.IsNullOrEmpty(c.src_object_fields_json))
//{
// conConfig.sourceObjectFields = JsonConvert.DeserializeObject<List<string>>(c.compare_object_fields);
//}
if (!string.IsNullOrEmpty(c.compare_config_json) && (c.dedup_source_type == SourceType.Copy_Source_data_to_Destination_and_Remove_Duplicates_from_Destination || c.dedup_source_type == SourceType.Merge_Table_A_Data_to_Table_B_and_Remove_Duplicates_from_Table_B))
{
conConfig.dbConfig_compare = JsonConvert.DeserializeObject <DatabaseConfig>(c.compare_config_json);
}
if (!string.IsNullOrEmpty(c.compare_object_fields))
{
conConfig.compareObjectFieldsMapping = JsonConvert.DeserializeObject <List <string> >(c.compare_object_fields);
if (c.dedup_source_type == SourceType.Remove_Duplicates_from_a_Single_Table || conConfig.compareObjectFieldsMapping != null)
{
conConfig.sourceObjectFields = conConfig.compareObjectFieldsMapping;
conConfig.dbConfig_compare.compareObjectFields = conConfig.compareObjectFieldsMapping;
}
}
//if (!string.IsNullOrEmpty(c.sync_log_json))
//{
// conConfig.connectorLogs = new ConnectorLogs()
// {
// sync_started_at = conConfig.syncStartedAt,
// sync_ended_at = conConfig.syncEndedAt,
// sync_count = conConfig.syncCount,
// sync_logs= JsonConvert.DeserializeObject<List<string>>(c.sync_log_json)
// };
//}
if (conConfig != null)
{
if (conConfig.syncDestination == ConnectorType.Heroku_Postgres ||
conConfig.syncDestination == ConnectorType.Azure_Postgres ||
conConfig.syncDestination == ConnectorType.AWS_Postgres ||
conConfig.syncDestination == ConnectorType.Azure_SQL)
{
DatabaseType databaseType;
if (conConfig.syncDestination == ConnectorType.Azure_SQL)
{
databaseType = DatabaseType.Azure_SQL;
}
else if (conConfig.syncDestination == ConnectorType.Azure_Postgres)
{
databaseType = DatabaseType.Azure_Postgres;
}
else if (conConfig.syncDestination == ConnectorType.AWS_Postgres)
{
databaseType = DatabaseType.AWS_Postgres;
}
else
{
databaseType = DatabaseType.Heroku_Postgres;
}
if (!string.IsNullOrEmpty(c.dest_config_json))
{
conConfig.destDBConfig = JsonConvert.DeserializeObject <DatabaseConfig>(c.dest_config_json);
if (conConfig.destDBConfig.databaseType == DatabaseType.None)
{
conConfig.destDBConfig.databaseType = databaseType;
}
}
else if (c.DeDupSetting != null && !string.IsNullOrEmpty(c.DeDupSetting.database_config_json))
{
conConfig.destDBConfig = c.DeDupSetting.ToModel <DatabaseConfig>(databaseType: databaseType);
}
}
if (string.IsNullOrEmpty(conConfig.dbSchema))
{
if ((conConfig.dataSource == DataSource.Heroku_Postgres ||
conConfig.dataSource == DataSource.Azure_Postgres ||
conConfig.dataSource == DataSource.AWS_Postgres))
{
conConfig.dbSchema = Constants.POSTGRES_DEFAULT_SCHEMA;
}
else if (conConfig.dataSource == DataSource.Azure_SQL)
{
conConfig.dbSchema = Constants.MSSQL_DEFAULT_SCHEMA;
}
}
if (string.IsNullOrEmpty(conConfig.destDBSchema))
{
if ((conConfig.syncDestination == ConnectorType.Heroku_Postgres ||
conConfig.syncDestination == ConnectorType.Azure_Postgres ||
conConfig.syncDestination == ConnectorType.AWS_Postgres))
{
conConfig.destDBSchema = Constants.POSTGRES_DEFAULT_SCHEMA;
}
else if (conConfig.syncDestination == ConnectorType.Azure_SQL)
{
conConfig.destDBSchema = Constants.MSSQL_DEFAULT_SCHEMA;
}
}
if (isSetConfig)
{
if (conConfig.dataSource == DataSource.Heroku_Postgres ||
conConfig.dataSource == DataSource.Azure_Postgres ||
conConfig.dataSource == DataSource.AWS_Postgres ||
conConfig.dataSource == DataSource.Azure_SQL)
{
DatabaseType databaseType;
if (conConfig.syncDestination == ConnectorType.Azure_SQL)
{
databaseType = DatabaseType.Azure_SQL;
}
else if (conConfig.syncDestination == ConnectorType.Azure_Postgres)
{
databaseType = DatabaseType.Azure_Postgres;
}
else if (conConfig.syncDestination == ConnectorType.AWS_Postgres)
{
databaseType = DatabaseType.AWS_Postgres;
}
else
{
databaseType = DatabaseType.Heroku_Postgres;
}
if (!string.IsNullOrEmpty(c.compare_config_json) && (c.dedup_source_type == SourceType.Copy_Source_data_to_Destination_and_Remove_Duplicates_from_Destination || c.dedup_source_type == SourceType.Merge_Table_A_Data_to_Table_B_and_Remove_Duplicates_from_Table_B))
{
if (c.compare_config_json.StartsWith("["))
{
conConfig.multipleDBConfigs.AddRange(JsonConvert.DeserializeObject <List <DatabaseConfig> >(c.compare_config_json));
//when multiple source assigned then we need to use th below line
//conConfig.dbConfig_compare = JsonConvert.DeserializeObject<DatabaseConfig>(connector.compare_config_json);
}
else
{
conConfig.dbConfig_compare = JsonConvert.DeserializeObject <DatabaseConfig>(c.compare_config_json);
conConfig.multipleDBConfigs.Add(conConfig.dbConfig_compare);
}
}
if (!string.IsNullOrEmpty(c.src_config_json))
{
conConfig.dbConfig = JsonConvert.DeserializeObject <DatabaseConfig>(c.src_config_json);
if (conConfig.dbConfig.databaseType == DatabaseType.None)
{
conConfig.dbConfig.databaseType = databaseType;
}
conConfig.dbConfig.db_schema = conConfig.dbSchema;
conConfig.dbConfig.object_name = conConfig.sourceObjectName;
conConfig.multipleDBConfigs.Add(conConfig.dbConfig);
}
else if (dedupSettings != null && !string.IsNullOrEmpty(dedupSettings.database_config_json))
{
conConfig.dbConfig = dedupSettings.ToModel <DatabaseConfig>(databaseType: databaseType);
conConfig.dbConfig.db_schema = conConfig.dbSchema;
conConfig.dbConfig.object_name = conConfig.sourceObjectName;
conConfig.multipleDBConfigs.Add(conConfig.dbConfig);
}
}
if (conConfig.syncDestination == ConnectorType.Heroku_Postgres ||
conConfig.syncDestination == ConnectorType.Azure_Postgres ||
conConfig.syncDestination == ConnectorType.AWS_Postgres ||
conConfig.syncDestination == ConnectorType.Azure_SQL)
{
DatabaseType databaseType;
if (conConfig.syncDestination == ConnectorType.Azure_SQL)
{
databaseType = DatabaseType.Azure_SQL;
}
else if (conConfig.syncDestination == ConnectorType.Azure_Postgres)
{
databaseType = DatabaseType.Azure_Postgres;
}
else if (conConfig.syncDestination == ConnectorType.AWS_Postgres)
{
databaseType = DatabaseType.AWS_Postgres;
}
else
{
databaseType = DatabaseType.Heroku_Postgres;
}
if (!string.IsNullOrEmpty(c.dest_config_json))
{
conConfig.destDBConfig = JsonConvert.DeserializeObject <DatabaseConfig>(c.dest_config_json);
if (conConfig.destDBConfig.databaseType == DatabaseType.None)
{
conConfig.destDBConfig.databaseType = databaseType;
}
}
else if (dedupSettings != null && !string.IsNullOrEmpty(dedupSettings.database_config_json))
{
conConfig.destDBConfig = dedupSettings.ToModel <DatabaseConfig>(databaseType: databaseType);
}
}
}
conConfig.child_record_count = SyncRepository.GetChildRecordsCount(conConfig);
}
return(conConfig);
}).ToList();
}
return(connectorConfigs as T);
}
else if (typeof(T) == typeof(List <ConnectorLogs>))
{
List <ConnectorLogs> connectorLogs = null;
if (connectors != null)
{
connectorLogs = connectors.Select(c =>
{
return(new ConnectorLogs()
{
sync_connector_name = c.connector_name,
sync_started_at = c.sync_started_at,
sync_ended_at = c.sync_ended_at,
sync_count = c.sync_count,
last_sync_at = c.last_sync_at,
last_sync_status = c.last_sync_status,
sync_status = c.sync_status,
sync_logs = Utilities.GetJsonPropertyValueByKeyPath <List <string> >(c.sync_log_json, "")
});
}).ToList();
}
return(connectorLogs as T);
}
return(null);
}
/// <summary>
/// Method: Add
/// Description: It is used to add new DeDupSettings to DeDupSettings table
/// </summary>
/// <param name="item"></param>
public void Add(DeDupSettings item)
{
_context.DeDupSettings.Add(item);
_context.SaveChanges();
}
/// <summary>
/// Method: Reload
/// Description: It is used to reload DeDupSettings entity
/// </summary>
/// <param name="entity"></param>
public void Reload(DeDupSettings entity)
{
_context.Entry <DeDupSettings>(entity).GetDatabaseValues();
}
public static T ToModel <T>(this DeDupSettings dedupSetting, string ccid = "", DatabaseType databaseType = DatabaseType.None) where T : class
{
if (dedupSetting != null && string.IsNullOrEmpty(ccid))
{
ccid = dedupSetting.ccid;
}
if (typeof(T) == typeof(DeDupSettings))
{
return(dedupSetting as T);
}
if (typeof(T) == typeof(DatabaseConfig))
{
DatabaseConfig databaseSetting = default(DatabaseConfig);
if (dedupSetting != null && !string.IsNullOrEmpty(dedupSetting.database_config_json))
{
try
{
databaseSetting = JsonConvert.DeserializeObject <List <DatabaseConfig> >(dedupSetting.database_config_json).FirstOrDefault(p => p.databaseType == databaseType);
}
catch (Exception ex)
{
Console.WriteLine("ERROR: {0}", ex.Message);
if (dedupSetting.database_config_json.Contains("databaseType") || databaseType == DatabaseType.Heroku_Postgres)
{
databaseSetting = JsonConvert.DeserializeObject <DatabaseConfig>(dedupSetting.database_config_json);
}
}
}
if (databaseSetting == null)
{
databaseSetting = new DatabaseConfig();
}
databaseSetting.ccid = ccid;
databaseSetting.databaseType = databaseType;
if (databaseSetting.databaseType == DatabaseType.None)
{
databaseSetting.databaseType = DatabaseType.Heroku_Postgres;
}
return(databaseSetting as T);
}
if (typeof(T) == typeof(List <DatabaseConfig>))
{
List <DatabaseConfig> databaseSettings = default(List <DatabaseConfig>);
if (dedupSetting != null && !string.IsNullOrEmpty(dedupSetting.database_config_json))
{
try
{
databaseSettings = JsonConvert.DeserializeObject <List <DatabaseConfig> >(dedupSetting.database_config_json);
}
catch (Exception ex)
{
Console.WriteLine("ERROR: {0}", ex.Message);
databaseSettings = new List <DatabaseConfig>()
{
JsonConvert.DeserializeObject <DatabaseConfig>(dedupSetting.database_config_json)
};
}
if (databaseSettings != null)
{
databaseSettings = databaseSettings.Select(p =>
{
p.ccid = ccid;
if (p.databaseType == DatabaseType.None)
{
p.databaseType = DatabaseType.Heroku_Postgres;
}
return(p);
}).ToList();
}
}
return(databaseSettings as T);
}
return(null);
}
