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); }