public async Task UpdateFromServer(SyncConfiguration conf)
{
Guid guid = Guid.NewGuid();
var updateRowScript =
$@"Update ""ServiceTickets"" Set ""Title"" = 'Updated from server {guid.ToString()}' Where ""ServiceTicketID"" = (SELECT ""ServiceTicketID"" FROM ""ServiceTickets"" LIMIT 1)";
using (var sqlConnection = new NpgsqlConnection(fixture.ServerConnectionString))
{
using (var sqlCmd = new NpgsqlCommand(updateRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
var serverProvider = new PostgreSqlSyncProvider(fixture.ServerConnectionString);
var clientProvider = new SqliteSyncProvider(fixture.ClientSqliteDb);
//var simpleConfiguration = new SyncConfiguration(Tables);
var agent = new SyncAgent(clientProvider, serverProvider);
agent.Configuration = conf;
agent.Configuration.Add(fixture.Tables);
var session = await agent.SynchronizeAsync();
Assert.Equal(1, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
}
public PostgreSqlSyncSimpleFixture()
{
// create databases
helperDb.ExecutePostgreSqlScript(serverDbName, "",
@"drop schema IF EXISTS ""unittest_dev"" cascade;
create schema ""unittest_dev"";
ALTER DEFAULT PRIVILEGES IN SCHEMA unittest_dev
GRANT ALL ON TABLES TO unittester;
GRANT ALL ON SCHEMA unittest_dev TO unittester; ");
// create table
helperDb.ExecutePostgreSqlScript(serverDbName, serverSchemaName, createTableScript);
// insert table
helperDb.ExecutePostgreSqlScript(serverDbName, serverSchemaName, datas);
if (File.Exists(ClientSqliteDb))
{
File.Delete(ClientSqliteDb);
}
var serverProvider = new PostgreSqlSyncProvider(ServerConnectionString);
var clientProvider = new SqliteSyncProvider(ClientSqliteDb);
var simpleConfiguration = new SyncConfiguration(Tables);
Agent = new SyncAgent(clientProvider, serverProvider, simpleConfiguration);
}
private async void SyncButton_Click(object sender, RoutedEventArgs e)
{
var clientProvider = new SqliteSyncProvider("employees.db");
var proxyClientProvider = new WebProxyClientProvider(
new Uri("http://localhost:58507/api/authsync"));
// adding bearer auth
if (authenticationResult != null && authenticationResult.AccessToken != null)
{
proxyClientProvider.AddCustomHeader("Authorization", authenticationResult.CreateAuthorizationHeader());
}
var agent = new SyncAgent(clientProvider, proxyClientProvider);
agent.SyncProgress += (s, a) => Debug(a.Message + a.PropertiesMessage);
try
{
var r = await agent.SynchronizeAsync();
Debug("TotalChangesDownloaded: " + r.TotalChangesDownloaded);
}
catch (Exception ex)
{
Debug("Error during sync " + ex.Message);
}
}
private static async Task SyncAdvAsync()
{
// Sql Server provider, the master.
var serverProvider = new SqlSyncProvider(
@"Data Source=.;Initial Catalog=AdventureWorks;User Id=sa;Password=Password12!;");
// Sqlite Client provider for a Sql Server <=> Sqlite sync
var clientProvider = new SqliteSyncProvider("advworks2.db");
// Tables involved in the sync process:
var tables = new string[] { "ProductCategory",
"ProductDescription", "ProductModel",
"Product", "ProductModelProductDescription",
"Address", "Customer", "CustomerAddress",
"SalesOrderHeader", "SalesOrderDetail" };
// Sync orchestrator
var agent = new SyncAgent(clientProvider, serverProvider, tables);
do
{
var s = await agent.SynchronizeAsync();
Console.WriteLine($"Total Changes downloaded : {s.TotalChangesDownloaded}");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
}
static async Task PerformSync()
{
var serverProvider = new SqlSyncProvider(
@"Data Source=.\sqlexpress;
Initial Catalog=AdventureWorks;
Integrated Security=true;");
var clientProvider = new SqliteSyncProvider("advworks.db");
var tablesToSync = new string[] {
"ProductCategory",
"ProductDescription", "ProductModel",
"Product", "ProductModelProductDescription",
"Address", "Customer", "CustomerAddress",
"SalesOrderHeader", "SalesOrderDetail"
};
var agent = new SyncAgent(clientProvider, serverProvider, tablesToSync);
var progress = new Progress <ProgressArgs>(s =>
Console.WriteLine($"{s.Context.SyncStage}:\t{s.Message}"));
do
{
var context = await agent.SynchronizeAsync(progress);
Console.WriteLine($"Total Changes downloaded: \t{context.TotalChangesDownloaded}");
Console.WriteLine($"Total Changes Uploaded: \t{context.TotalChangesUploaded}");
Console.WriteLine($"Total Changes Conflicts: \t{context.TotalSyncConflicts}");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
}
public SqliteSyncHttpTests(SqliteSyncHttpFixture fixture)
{
this.fixture = fixture;
configurationProvider = () => new SyncConfiguration(fixture.Tables);
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
proxyServerProvider = new WebProxyServerProvider(serverProvider);
webApp = WebApp.Start(fixture.BaseAddress.OriginalString, (appBuilder) =>
{
// Configure Web API for self-host.
HttpConfiguration config = new HttpConfiguration();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{actionid}/{id}",
defaults: new { actionid = RouteParameter.Optional, id = RouteParameter.Optional }
);
config.Services.Replace(typeof(IHttpControllerActivator), new TestControllerActivator(
() =>
{
proxyServerProvider.Configuration = configurationProvider();
return(proxyServerProvider);
}));
appBuilder.UseWebApi(config);
});
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
proxyClientProvider = new WebProxyClientProvider(new Uri(fixture.BaseAddress, "api/values"));
agent = new SyncAgent(clientProvider, proxyClientProvider);
}
private static async Task SynchronizeAsync(SqlSyncProvider serverProvider, SqliteSyncProvider clientProvider)
{
// Tables involved in the sync process:
var tables = new string[] { "ServiceTickets" };
// Creating an agent that will handle all the process
var agent = new SyncAgent(clientProvider, serverProvider);
// Launch the sync process
var s1 = await agent.SynchronizeAsync(tables);
// This first sync did not upload the client rows.
// We only have rows from server that have been downloaded
// The important step here is to have setup the sync (triggers / tracking tables ...)
Console.WriteLine(s1);
// Now we can "mark" original clients rows as "to be uploaded"
await agent.LocalOrchestrator.UpdateUntrackedRowsAsync();
// Then we can make a new synchronize to upload these rows to server
// Launch the sync process
var s2 = await agent.SynchronizeAsync();
Console.WriteLine(s2);
}
private static async Task SynchronizeAsync()
{
// Database script used for this sample : https://github.com/Mimetis/Dotmim.Sync/blob/master/CreateAdventureWorks.sql
// Create 2 Sql Sync providers
// First provider is using the Sql change tracking feature. Don't forget to enable it on your database until running this code !
// For instance, use this SQL statement on your server database : ALTER DATABASE AdventureWorks SET CHANGE_TRACKING = ON (CHANGE_RETENTION = 10 DAYS, AUTO_CLEANUP = ON)
// Otherwise, if you don't want to use Change Tracking feature, just change 'SqlSyncChangeTrackingProvider' to 'SqlSyncProvider'
var serverProvider = new SqlSyncProvider(serverConnectionString);
// Second provider is using plain old Sql Server provider, relying on triggers and tracking tables to create the sync environment
var clientProvider = new SqliteSyncProvider("adv.db");
// Tables involved in the sync process:
var tables = new string[] { "ProductCategory", "ProductModel", "Product",
"Address", "Customer", "CustomerAddress", "SalesOrderHeader", "SalesOrderDetail" };
// Creating an agent that will handle all the process
var agent = new SyncAgent(clientProvider, serverProvider, tables);
do
{
// Launch the sync process
var s1 = await agent.SynchronizeAsync();
// Write results
Console.WriteLine(s1);
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
public SqliteSyncAllColumnsFixture()
{
var builder = new SqliteConnectionStringBuilder { DataSource = ClientSqliteFilePath };
this.ClientSqliteConnectionString = builder.ConnectionString;
GC.Collect();
GC.WaitForPendingFinalizers();
if (File.Exists(ClientSqliteFilePath))
File.Delete(ClientSqliteFilePath);
// create databases
helperDb.CreateDatabase(serverDbName);
// create table
helperDb.ExecuteScript(serverDbName, createTableScript);
// insert table
helperDb.ExecuteScript(serverDbName, datas);
var serverProvider = new SqlSyncProvider(ServerConnectionString);
var clientProvider = new SqliteSyncProvider(ClientSqliteFilePath);
var simpleConfiguration = new SyncConfiguration(new[] { "AllColumns" });
Agent = new SyncAgent(clientProvider, serverProvider, simpleConfiguration);
}
private async void button1_Click(object sender, EventArgs e)
{
// Database script used for this sample : https://github.com/Mimetis/Dotmim.Sync/blob/master/CreateAdventureWorks.sql
// Create 2 Sql Sync providers
// First provider is using the Sql change tracking feature. Don't forget to enable it on your database until running this code !
// For instance, use this SQL statement on your server database : ALTER DATABASE AdventureWorks SET CHANGE_TRACKING = ON (CHANGE_RETENTION = 10 DAYS, AUTO_CLEANUP = ON)
// Otherwise, if you don't want to use Change Tracking feature, just change 'SqlSyncChangeTrackingProvider' to 'SqlSyncProvider'
var serverProvider = new SqlSyncProvider(serverConnectionString);
// Second provider is using plain old Sql Server provider, relying on triggers and tracking tables to create the sync environment
var clientProvider = new SqliteSyncProvider(dbName);
// Tables involved in the sync process:
var setup = new SyncSetup("ProductCategory", "ProductModel", "Product",
"Address", "Customer", "CustomerAddress", "SalesOrderHeader", "SalesOrderDetail");
// Creating an agent that will handle all the process
var agent = new SyncAgent(clientProvider, serverProvider);
// Launch the sync process
var s1 = await agent.SynchronizeAsync(setup);
// Write results
MessageBox.Show(s1.ToString());
}
public SqliteTwoTablesTests(SqliteTwoTablesFixture fixture)
{
this.fixture = fixture;
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
agent = new SyncAgent(clientProvider, serverProvider, fixture.Tables);
}
public SqliteSyncReservedKeyWordsTests(SqliteSyncReservedKeyWordsFixture fixture)
{
this.fixture = fixture;
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
var simpleConfiguration = new SyncConfiguration(fixture.Tables);
agent = new SyncAgent(clientProvider, serverProvider, simpleConfiguration);
}
public SyncWithClientInitialDatasTests(SyncWithClientInitialDatasTestsFixture fixture)
{
this.fixture = fixture;
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
var simpleConfiguration = new SyncConfiguration(fixture.Tables);
agent = new SyncAgent(clientProvider, serverProvider, fixture.Tables);
}
public async Task SyncSqlite()
{
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
sqliteClientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
agent = new SyncAgent(sqliteClientProvider, serverProvider, fixture.Tables);
var session = await agent.SynchronizeAsync();
Assert.Equal(4276, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
}
public SqliteEncryptedTests()
{
this.sqlTables = new string[]
{
"SalesLT.ProductCategory", "SalesLT.ProductModel", "SalesLT.Product", "Employee", "Customer", "Address", "CustomerAddress", "EmployeeAddress",
"SalesLT.SalesOrderHeader", "SalesLT.SalesOrderDetail", "dbo.Sql", "Posts", "Tags", "PostTag",
"PricesList", "PriceListCategory", "PriceListDetail"
};
this.serverProvider = new SqlSyncProvider(serverCString);
this.clientProvider = new SqliteSyncProvider(clientCString);
}
static async Task Main(string[] args)
{
Console.WriteLine("Be sure the web api has started. Then click enter..");
Console.ReadLine();
var clientProvider1 = new SqlSyncProvider(clientConnectionString);
var clientProvider2 = new SqliteSyncProvider("client2.db");
var clientProvider3 = new SqliteSyncProvider("client3.db");
await SynchronizeAsync(clientProvider1);
await SynchronizeAsync(clientProvider2);
await SynchronizeAsync(clientProvider3);
}
public SqliteSyncHttpTests(SqliteSyncHttpFixture fixture)
{
this.fixture = fixture;
serverProvider = new SqlSyncProvider(fixture.ServerConnectionString);
proxyServerProvider = new WebProxyServerProvider(serverProvider);
clientProvider = new SqliteSyncProvider(fixture.ClientSqliteFilePath);
proxyClientProvider = new WebProxyClientProvider();
agent = new SyncAgent(clientProvider, proxyClientProvider);
}
public SqliteSyncSimpleFixture()
{
var builder = new SqliteConnectionStringBuilder {
DataSource = ClientSqliteFilePath
};
this.ClientSqliteConnectionString = builder.ConnectionString;
if (File.Exists(ClientSqliteFilePath))
{
File.Delete(ClientSqliteFilePath);
}
// create databases
helperDb.CreateDatabase(serverDbName);
// create table
helperDb.ExecuteScript(serverDbName, createTableScript);
// insert table
helperDb.ExecuteScript(serverDbName, datas);
var serverProvider = new SqlSyncProvider(ServerConnectionString);
SqliteConnection c = new SqliteConnection($"Data Source=fabrikamde.db");
c.StateChange += (_, e) =>
{
if (e.CurrentState == ConnectionState.Open)
{
var cmd = c.CreateCommand();
cmd.CommandText = "PRAGMA journal_mode=WAL;";
var i = cmd.ExecuteScalar();
}
};
c.Open();
c.Close();
var clientProvider = new SqliteSyncProvider(ClientSqliteFilePath);
var totoClientProvider = new SqliteSyncProvider(
@"Data Source=D:\database\myData.db;Journal Mode=WAL;Page Size=8192");
SqliteConnectionStringBuilder sqliteConnectionStringBuilder = new SqliteConnectionStringBuilder();
var simpleConfiguration = new SyncConfiguration(Tables);
Agent = new SyncAgent(clientProvider, serverProvider, simpleConfiguration);
}
static async Task Main()
{
// Database script used for this sample : https://github.com/Mimetis/Dotmim.Sync/blob/master/CreateAdventureWorks.sql
var serverProvider = new SqlSyncProvider(serverConnectionString);
// Second provider is using plain old Sql Server provider, relying on triggers and tracking tables to create the sync environment
var clientProvider = new SqliteSyncProvider("adv.db");
// Setup two tables with datas in each table
await SetupDatabasesAsync(serverProvider, clientProvider);
// SynchronizeAsync: Double SynchronizeAsync with UpdateUntrackedRowsAsync
await SynchronizeAsync(serverProvider, clientProvider);
}
private static async Task FilterSync()
{
// Get SQL Server connection string
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("config.json", true);
IConfiguration Configuration = configurationBuilder.Build();
var serverConfig = Configuration["AppConfiguration:ServerFilteredConnectionString"];
var clientConfig = "sqlitefiltereddb.db";
SqlSyncProvider serverProvider = new SqlSyncProvider(serverConfig);
SqliteSyncProvider clientProvider = new SqliteSyncProvider(clientConfig);
// With a config when we are in local mode (no proxy)
SyncConfiguration configuration = new SyncConfiguration(new string[] { "ServiceTickets" });
//configuration.DownloadBatchSizeInKB = 500;
configuration.UseBulkOperations = false;
// Adding filters on schema
configuration.Filters.Add("ServiceTickets", "CustomerID");
SyncAgent agent = new SyncAgent(clientProvider, serverProvider, configuration);
// Adding a parameter for this agent
agent.Parameters.Add("ServiceTickets", "CustomerID", 1);
do
{
Console.Clear();
Console.WriteLine("Sync Start");
try
{
var s = await agent.SynchronizeAsync();
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
private static async Task SynchronizeAsync()
{
// Database script used for this sample : https://github.com/Mimetis/Dotmim.Sync/blob/master/CreateAdventureWorks.sql
var serverOrchestrator = new WebRemoteOrchestrator("https://localhost:44342/api/sync");
//var clientProvider = new SqlSyncProvider(clientConnectionString);
var clientProvider = new SqliteSyncProvider("adv.db");
var clientOptions = new SyncOptions {
BatchSize = 100, ProgressLevel = SyncProgressLevel.Debug
};
var progress = new SynchronousProgress <ProgressArgs>(
s => Console.WriteLine($"{s.ProgressPercentage:p}: \t[{s.Source[..Math.Min(4, s.Source.Length)]}] {s.TypeName}:\t{s.Message}"));
private static async Task TestSyncSqlite()
{
// Get SQL Server connection string
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("config.json", true);
IConfiguration Configuration = configurationBuilder.Build();
var serverConfig = Configuration["AppConfiguration:ServerConnectionString"];
var clientConfig = "fabrikam3.db";
SqlSyncProvider serverProvider = new SqlSyncProvider(serverConfig);
SqliteSyncProvider clientProvider = new SqliteSyncProvider(clientConfig);
// With a config when we are in local mode (no proxy)
SyncConfiguration configuration = new SyncConfiguration(new string[]
{ "ServiceTickets" });
SyncAgent agent = new SyncAgent(clientProvider, serverProvider, configuration);
agent.SyncProgress += SyncProgress;
agent.ApplyChangedFailed += ApplyChangedFailed;
do
{
Console.Clear();
Console.WriteLine("Sync Start");
try
{
var s = await agent.SynchronizeAsync();
}
catch (SyncException e)
{
Console.WriteLine(e.ToString());
}
catch (Exception e)
{
Console.WriteLine("UNKNOW EXCEPTION : " + e.Message);
}
Console.WriteLine("Sync Ended. Press a key to start again, or Escapte to end");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
Console.WriteLine("End");
}
public async Task Test1_Sqlite_Sqlite()
{
var localDbFile = $"{Path.GetTempPath()}Test1_Sqlite_Sqlite_local.sqlite";
var remoteDbFile = $"{Path.GetTempPath()}Test1_Sqlite_Sqlite_remote.sqlite";
if (File.Exists(localDbFile))
{
File.Delete(localDbFile);
}
if (File.Exists(remoteDbFile))
{
File.Delete(remoteDbFile);
}
using (var localDb = new SqliteBlogDbContext($"Data Source={localDbFile}"))
using (var remoteDb = new SqliteBlogDbContext($"Data Source={remoteDbFile}"))
{
await localDb.Database.EnsureDeletedAsync();
await remoteDb.Database.EnsureDeletedAsync();
await localDb.Database.MigrateAsync();
await remoteDb.Database.MigrateAsync();
var remoteConfigurationBuilder =
new SqliteSyncConfigurationBuilder(remoteDb.ConnectionString)
.Table <User>("Users")
.Table <Post>("Posts")
.Table <Comment>("Comments");
var remoteSyncProvider = new SqliteSyncProvider(remoteConfigurationBuilder.Configuration);
var localConfigurationBuilder =
new SqliteSyncConfigurationBuilder(localDb.ConnectionString)
.Table <User>("Users")
.Table <Post>("Posts")
.Table <Comment>("Comments");
var localSyncProvider = new SqliteSyncProvider(localConfigurationBuilder.Configuration);
await Test1(localDb, localSyncProvider, remoteDb, remoteSyncProvider);
}
}
public async Task Test_Sqlite_Sqlite_DataRetention()
{
var localDbFile = $"{Path.GetTempPath()}Test_Sqlite_Sqlite_DataRetention_local.sqlite";
var remoteDbFile = $"{Path.GetTempPath()}Test_Sqlite_Sqlite_DataRetention_remote.sqlite";
if (File.Exists(localDbFile))
{
File.Delete(localDbFile);
}
if (File.Exists(remoteDbFile))
{
File.Delete(remoteDbFile);
}
using (var localDb = new SqliteBlogDbContext($"Data Source={localDbFile}"))
using (var remoteDb = new SqliteBlogDbContext($"Data Source={remoteDbFile}"))
{
await localDb.Database.EnsureDeletedAsync();
await remoteDb.Database.EnsureDeletedAsync();
await localDb.Database.MigrateAsync();
await remoteDb.Database.MigrateAsync();
var remoteConfigurationBuilder =
new SqliteSyncConfigurationBuilder(remoteDb.ConnectionString)
.Table("Users")
.Table("Posts")
.Table("Comments");
var remoteSyncProvider = new SqliteSyncProvider(remoteConfigurationBuilder.Build(), ProviderMode.Remote, logger: new ConsoleLogger("REM"));
var localConfigurationBuilder =
new SqliteSyncConfigurationBuilder(localDb.ConnectionString)
.Table <User>("Users")
.Table <Post>("Posts")
.Table <Comment>("Comments");
var localSyncProvider = new SqliteSyncProvider(localConfigurationBuilder.Build(), ProviderMode.Local, logger: new ConsoleLogger("LOC"));
await TestSyncAgentWithDataRetention(localDb, localSyncProvider, remoteDb, remoteSyncProvider);
}
}
private void Init()
{
// Servers providers
masterSqlSyncProvider = new SqlSyncProvider(
settingsHelper[ConnectionType.Server_SqlServer]);
webProxyProvider = new WebClientOrchestrator(settingsHelper[ConnectionType.WebProxy]);
// clients providers
sqlSyncProvider = new SqlSyncProvider(
settingsHelper[ConnectionType.Client_SqlServer]);
sqliteSyncProvider = new SqliteSyncProvider(
settingsHelper[ConnectionType.Client_Sqlite]);
mySqlSyncProvider = new MySqlSyncProvider(
settingsHelper[ConnectionType.Client_MySql]);
}
public async Task Test1_SqlServer_Sqlite()
{
var remoteDbFile = $"{Path.GetTempPath()}Test1_SqlServer_Sqlite_remote.sqlite";
if (File.Exists(remoteDbFile))
{
File.Delete(remoteDbFile);
}
using var localDb = new SqlServerBlogDbContext(ConnectionString + ";Initial Catalog=Test1_Local");
using var remoteDb = new SqliteBlogDbContext($"Data Source={remoteDbFile}");
await localDb.Database.EnsureDeletedAsync();
await remoteDb.Database.EnsureDeletedAsync();
await localDb.Database.MigrateAsync();
await remoteDb.Database.MigrateAsync();
var remoteConfigurationBuilder =
new SqliteSyncConfigurationBuilder(remoteDb.ConnectionString)
.Table <User>("Users")
.Table <Post>("Posts")
.Table <Comment>("Comments");
var remoteSyncProvider = new SqliteSyncProvider(remoteConfigurationBuilder.Build(), logger: new ConsoleLogger("REM"));
await remoteSyncProvider.ApplyProvisionAsync();
var localConfigurationBuilder =
new SqlSyncConfigurationBuilder(localDb.ConnectionString)
.Table("Users")
.Table("Posts")
.Table("Comments");
var localSyncProvider = new SqlSyncProvider(localConfigurationBuilder.Build(), logger: new ConsoleLogger("LOC"));
await localSyncProvider.ApplyProvisionAsync();
await Test1(localDb, localSyncProvider, remoteDb, remoteSyncProvider);
}
static async Task PerformSync()
{
var serverUri = new Uri(Properties.Settings.Default.SyncServer);
var proxyClientProvider = new WebProxyClientProvider(serverUri);
var clientProvider = new SqliteSyncProvider("advworks.db");
var agent = new SyncAgent(clientProvider, proxyClientProvider);
var progress = new Progress <ProgressArgs>(s =>
Console.WriteLine($"{s.Context.SyncStage}:\t{s.Message}"));
do
{
var context = await agent.SynchronizeAsync(progress);
Console.WriteLine($"Total Changes downloaded: \t{context.TotalChangesDownloaded}");
Console.WriteLine($"Total Changes Uploaded: \t{context.TotalChangesUploaded}");
Console.WriteLine($"Total Changes Conflicts: \t{context.TotalSyncConflicts}");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
}
private static async Task TrySyncAzureSqlDbAsync()
{
// Sql Server provider, the master.
var serverProvider = new SqlSyncProvider(
@"Data Source=sebpertus.database.windows.net;Initial Catalog=AdventureWorks;User Id=YOUR_ID;Password=YOUR_PASSWORD;");
// Sqlite Client provider for a Sql Server <=> Sqlite sync
var clientProvider = new SqliteSyncProvider("advfromazure.db");
// Tables involved in the sync process:
var tables = new string[] { "Address" };
// Sync orchestrator
var agent = new SyncAgent(clientProvider, serverProvider, tables);
do
{
var s = await agent.SynchronizeAsync();
Console.WriteLine($"Total Changes downloaded : {s.TotalChangesDownloaded}");
} while (Console.ReadKey().Key != ConsoleKey.Escape);
}
private static void TestSqliteDoubleStatement()
{
var clientProvider = new SqliteSyncProvider(@"C:\PROJECTS\DOTMIM.SYNC\Tests\Dotmim.Sync.Tests\bin\Debug\netcoreapp2.0\st_r55jmmolvwg.db");
var clientConnection = new SqliteConnection(clientProvider.ConnectionString);
var commandText = "Update ProductCategory Set Name=@Name Where ProductCategoryId=@Id; " +
"Select * from ProductCategory Where ProductCategoryId=@Id;";
using (DbCommand command = clientConnection.CreateCommand())
{
command.Connection = clientConnection;
command.CommandText = commandText;
var p = command.CreateParameter();
p.ParameterName = "@Id";
p.DbType = DbType.String;
p.Value = "FTNLBJ";
command.Parameters.Add(p);
p = command.CreateParameter();
p.ParameterName = "@Name";
p.DbType = DbType.String;
p.Value = "Awesome Bike";
command.Parameters.Add(p);
clientConnection.Open();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var name = reader["Name"];
Console.WriteLine(name);
}
}
clientConnection.Close();
}
}
public SyncServices()
{
this.settings = DependencyService.Get <ISettingServices>();
var syncApiUri = new Uri(this.settings.SyncApiUrl);
this.httpClient = new HttpClient();
#if DEBUG
var handler = DependencyService.Get <IHttpClientHandlerService>().GetInsecureHandler();
#else
var handler = new HttpClientHandler();
#endif
handler.AutomaticDecompression = DecompressionMethods.GZip;
this.httpClient = new HttpClient(handler);
// Check if we are trying to reach a IIS Express.
// IIS Express does not allow any request other than localhost
// So far,hacking the Host-Content header to mimic localhost call
if (Device.RuntimePlatform == Device.Android && syncApiUri.Host == "10.0.2.2")
{
this.httpClient.DefaultRequestHeaders.Host = $"localhost:{syncApiUri.Port}";
}
this.httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
this.webProxyProvider = new WebRemoteOrchestrator(this.settings.SyncApiUrl, client: this.httpClient);
this.sqliteSyncProvider = new SqliteSyncProvider(this.settings.DataSource);
var clientOptions = new SyncOptions {
BatchSize = settings.BatchSize, BatchDirectory = settings.BatchDirectoryPath
};
this.syncAgent = new SyncAgent(sqliteSyncProvider, webProxyProvider, clientOptions);
}
