public async Task <SyncContext> EnsureDatabaseAsync(SyncContext context, MessageEnsureDatabase message)
{
HttpMessage httpMessage = new HttpMessage
{
SyncContext = context,
Step = HttpStep.EnsureDatabase,
Content = new HttpMessageEnsureDatabase
{
ScopeInfo = message.ScopeInfo,
Schema = new DmSetSurrogate(message.Schema),
Filters = message.Filters,
SerializationFormat = message.SerializationFormat
}
};
//Post request and get response
var httpMessageResponse = await this.httpRequestHandler.ProcessRequest(httpMessage, message.SerializationFormat, cancellationToken);
if (httpMessageResponse == null)
{
throw new Exception("Can't have an empty body");
}
return(httpMessageResponse.SyncContext);
}
/// <summary>
/// Be sure all tables are ready and configured for sync
/// the ScopeSet Configuration MUST be filled by the schema form Database
/// </summary>
public virtual async Task <SyncContext> EnsureDatabaseAsync(SyncContext context, MessageEnsureDatabase message)
{
DbConnection connection = null;
try
{
// Event progress
context.SyncStage = SyncStage.DatabaseApplying;
DatabaseApplyingEventArgs beforeArgs =
new DatabaseApplyingEventArgs(this.ProviderTypeName, context.SyncStage, message.Schema);
this.TryRaiseProgressEvent(beforeArgs, this.DatabaseApplying);
// If scope exists and lastdatetime sync is present, so database exists
// Check if we don't have an OverwriteConfiguration (if true, we force the check)
if (message.ScopeInfo.LastSync.HasValue && !beforeArgs.OverwriteSchema)
{
return(context);
}
StringBuilder script = new StringBuilder();
// Open the connection
using (connection = this.CreateConnection())
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction())
{
foreach (var dmTable in message.Schema.Tables)
{
var builder = GetDatabaseBuilder(dmTable);
// adding filter
this.AddFilters(message.Filters, dmTable, builder);
context.SyncStage = SyncStage.DatabaseTableApplying;
DatabaseTableApplyingEventArgs beforeTableArgs =
new DatabaseTableApplyingEventArgs(this.ProviderTypeName, context.SyncStage, dmTable.TableName);
this.TryRaiseProgressEvent(beforeTableArgs, this.DatabaseTableApplying);
string currentScript = null;
if (beforeArgs.GenerateScript)
{
currentScript = builder.ScriptTable(connection, transaction);
currentScript += builder.ScriptForeignKeys(connection, transaction);
script.Append(currentScript);
}
builder.Create(connection, transaction);
builder.CreateForeignKeys(connection, transaction);
context.SyncStage = SyncStage.DatabaseTableApplied;
DatabaseTableAppliedEventArgs afterTableArgs =
new DatabaseTableAppliedEventArgs(this.ProviderTypeName, context.SyncStage, dmTable.TableName, currentScript);
this.TryRaiseProgressEvent(afterTableArgs, this.DatabaseTableApplied);
}
context.SyncStage = SyncStage.DatabaseApplied;
var afterArgs = new DatabaseAppliedEventArgs(this.ProviderTypeName, context.SyncStage, script.ToString());
this.TryRaiseProgressEvent(afterArgs, this.DatabaseApplied);
transaction.Commit();
}
connection.Close();
return(context);
}
}
catch (Exception ex)
{
throw new SyncException(ex, SyncStage.DatabaseApplying, this.ProviderTypeName);
}
finally
{
if (connection != null && connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
}
/// <summary>
/// Be sure all tables are ready and configured for sync
/// the ScopeSet Configuration MUST be filled by the schema form Database
/// </summary>
public virtual async Task <SyncContext> EnsureDatabaseAsync(SyncContext context, MessageEnsureDatabase message)
{
DbConnection connection = null;
try
{
// Event progress
context.SyncStage = SyncStage.DatabaseApplying;
var script = new StringBuilder();
// Open the connection
using (connection = this.CreateConnection())
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction())
{
var beforeArgs =
new DatabaseApplyingEventArgs(this.ProviderTypeName, context.SyncStage, message.Schema, connection, transaction);
this.TryRaiseProgressEvent(beforeArgs, this.DatabaseApplying);
if (message.ScopeInfo.LastSync.HasValue && !beforeArgs.OverwriteSchema)
{
return(context);
}
// Sorting tables based on dependencies between them
var dmTables = message.Schema.Tables
.SortByDependencies(tab => tab.ChildRelations
.Select(r => r.ChildTable));
foreach (var dmTable in dmTables)
{
var builder = this.GetDatabaseBuilder(dmTable);
// set if the builder supports creating the bulk operations proc stock
builder.UseBulkProcedures = this.SupportBulkOperations;
// adding filter
this.AddFilters(message.Filters, dmTable, builder);
context.SyncStage = SyncStage.DatabaseTableApplying;
var beforeTableArgs =
new DatabaseTableApplyingEventArgs(this.ProviderTypeName, context.SyncStage, dmTable.TableName, connection, transaction);
this.TryRaiseProgressEvent(beforeTableArgs, this.DatabaseTableApplying);
string currentScript = null;
if (beforeArgs.GenerateScript)
{
currentScript = builder.ScriptTable(connection, transaction);
currentScript += builder.ScriptForeignKeys(connection, transaction);
script.Append(currentScript);
}
builder.Create(connection, transaction);
builder.CreateForeignKeys(connection, transaction);
context.SyncStage = SyncStage.DatabaseTableApplied;
var afterTableArgs =
new DatabaseTableAppliedEventArgs(this.ProviderTypeName, context.SyncStage, dmTable.TableName, currentScript, connection, transaction);
this.TryRaiseProgressEvent(afterTableArgs, this.DatabaseTableApplied);
}
context.SyncStage = SyncStage.DatabaseApplied;
var afterArgs = new DatabaseAppliedEventArgs(this.ProviderTypeName, context.SyncStage, script.ToString(), connection, transaction);
this.TryRaiseProgressEvent(afterArgs, this.DatabaseApplied);
transaction.Commit();
}
connection.Close();
return(context);
}
}
catch (Exception ex)
{
throw new SyncException(ex, SyncStage.DatabaseApplying, this.ProviderTypeName);
}
finally
{
if (connection != null && connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
}
public async Task <SyncContext> EnsureDatabaseAsync(SyncContext ctx, MessageEnsureDatabase message) => await this.LocalProvider.EnsureDatabaseAsync(ctx, message);
/// <summary>
/// Be sure all tables are ready and configured for sync
/// the ScopeSet Configuration MUST be filled by the schema form Database
/// </summary>
public virtual async Task <SyncContext> EnsureDatabaseAsync(SyncContext context, MessageEnsureDatabase message)
{
DbConnection connection = null;
DbTransaction transaction = null;
try
{
// Event progress
context.SyncStage = SyncStage.SchemaApplying;
var script = new StringBuilder();
// Open the connection
using (connection = this.CreateConnection())
{
await connection.OpenAsync();
await this.InterceptAsync(new ConnectionOpenArgs(context, connection));
using (transaction = connection.BeginTransaction())
{
// Interceptors
await this.InterceptAsync(new TransactionOpenArgs(context, connection, transaction));
var beforeArgs = new DatabaseProvisioningArgs(context, SyncProvision.All, message.Schema, connection, transaction);
await this.InterceptAsync(beforeArgs);
if (message.ScopeInfo.LastSync.HasValue && !beforeArgs.OverwriteSchema)
{
return(context);
}
// Sorting tables based on dependencies between them
var dmTables = message.Schema.Tables
.SortByDependencies(tab => tab.ChildRelations
.Select(r => r.ChildTable));
foreach (var dmTable in dmTables)
{
var builder = this.GetDatabaseBuilder(dmTable);
// set if the builder supports creating the bulk operations proc stock
builder.UseBulkProcedures = this.SupportBulkOperations;
// adding filter
this.AddFilters(message.Filters, dmTable, builder);
context.SyncStage = SyncStage.TableSchemaApplying;
// Launch any interceptor if available
await this.InterceptAsync(new TableProvisioningArgs(context, SyncProvision.All, dmTable, connection, transaction));
string currentScript = null;
if (beforeArgs.GenerateScript)
{
currentScript = builder.ScriptTable(connection, transaction);
currentScript += builder.ScriptForeignKeys(connection, transaction);
script.Append(currentScript);
}
builder.Create(connection, transaction);
builder.CreateForeignKeys(connection, transaction);
// Report & Interceptor
context.SyncStage = SyncStage.TableSchemaApplied;
var tableProvisionedArgs = new TableProvisionedArgs(context, SyncProvision.All, dmTable, connection, transaction);
this.ReportProgress(context, tableProvisionedArgs);
await this.InterceptAsync(tableProvisionedArgs);
}
// Report & Interceptor
context.SyncStage = SyncStage.SchemaApplied;
var args = new DatabaseProvisionedArgs(context, SyncProvision.All, message.Schema, script.ToString(), connection, transaction);
this.ReportProgress(context, args);
await this.InterceptAsync(args);
await this.InterceptAsync(new TransactionCommitArgs(context, connection, transaction));
transaction.Commit();
}
connection.Close();
return(context);
}
}
catch (Exception ex)
{
throw new SyncException(ex, SyncStage.SchemaApplying);
}
finally
{
if (connection != null && connection.State != ConnectionState.Closed)
{
connection.Close();
}
await this.InterceptAsync(new ConnectionCloseArgs(context, connection, transaction));
}
}
