public async Task <IActionResult> Edit(int id, [Bind("Id,TagName,BackColor,ImagePath,Text,DataId,LangId")] CoreProvider coreProvider)
{
if (id != coreProvider.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(coreProvider);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CoreProviderExists(coreProvider.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(coreProvider));
}
/// <summary>
/// Default ctor. Using default options and schema
/// </summary>
/// <param name="provider"></param>
public WebServerOrchestrator(CoreProvider provider, SyncOptions options, WebServerOptions webServerOptions, SyncSetup setup, IMemoryCache cache = null, string scopeName = SyncOptions.DefaultScopeName)
: base(provider, options, setup, scopeName)
{
this.WebServerOptions = webServerOptions ?? throw new ArgumentNullException(nameof(webServerOptions));
this.Cache = cache ?? new MemoryCache(new MemoryCacheOptions());
}
public async Task <IActionResult> Create([Bind("Id,TagName,BackColor,ImagePath,Text,DataId,LangId")] CoreProvider coreProvider)
{
if (ModelState.IsValid)
{
_context.Add(coreProvider);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(coreProvider));
}
public ProviderRun(string databaseName, CoreProvider clientProvider, ProviderType clientProviderType, NetworkType networkType)
{
if (string.IsNullOrEmpty(databaseName))
{
throw new ArgumentNullException(nameof(databaseName));
}
this.DatabaseName = databaseName;
this.ClientProvider = clientProvider ?? throw new ArgumentNullException(nameof(clientProvider));
this.NetworkType = networkType;
this.ClientProviderType = clientProviderType;
}
/// <summary>
/// Create a new WebProxyServerProvider with a first instance of an in memory CoreProvider
/// Use this method to create your WebProxyServerProvider if you don't use the DI stuff from ASP.NET
/// </summary>
public static WebProxyServerProvider Create(HttpContext context, CoreProvider provider, Action <SyncConfiguration> conf, Action <SyncOptions> options)
{
if (!TryGetHeaderValue(context.Request.Headers, "dotmim-sync-session-id", out var sessionId))
{
throw new SyncException($"Can't find any session id in the header");
}
// Check if we have already a cached Sync Memory provider
var syncMemoryProvider = GetCachedProviderInstance(context, sessionId);
// we don't have any provider for this session id, so create it
if (syncMemoryProvider == null)
{
AddNewProviderToCache(context, provider, conf, options, sessionId);
}
return(defaultInstance);
}
private static SyncMemoryProvider AddNewProviderToCache(HttpContext context, CoreProvider provider, Action <SyncConfiguration> conf, Action <SyncOptions> options, string sessionId)
{
SyncMemoryProvider syncMemoryProvider;
var cache = context.RequestServices.GetService <IMemoryCache>();
if (cache == null)
{
throw new SyncException("Cache is not configured! Please add memory cache, distributed or not (see https://docs.microsoft.com/en-us/aspnet/core/performance/caching/response?view=aspnetcore-2.2)");
}
syncMemoryProvider = new SyncMemoryProvider(provider);
syncMemoryProvider.SetConfiguration(conf);
syncMemoryProvider.SetOptions(options);
cache.Set(sessionId, syncMemoryProvider, TimeSpan.FromHours(1));
return(syncMemoryProvider);
}
/// <summary>
/// Will configure the fixture on first test launch
/// </summary>
internal void Configure()
{
// Pattern double check to be sur one instance is not trying to create the databse during an other trying to delete the same one.
lock (locker)
{
if (isConfigured)
{
return;
}
lock (locker)
{
if (isConfigured)
{
return;
}
// gets the server provider
this.ServerProvider = this.NewServerProvider(HelperDB.GetConnectionString(this.ProviderType, this.DatabaseName));
// create the server database
this.ServerDatabaseEnsureCreated();
// Get all provider fixture
var listOfBs = (from assemblyType in typeof(ProviderFixture).Assembly.DefinedTypes
where typeof(ProviderFixture).IsAssignableFrom(assemblyType) &&
assemblyType.BaseType == typeof(ProviderFixture)
select assemblyType).ToArray();
foreach (var t in listOfBs)
{
var c = GetDefaultConstructor(t);
var instance = c.Invoke(null) as ProviderFixture;
RegisterProvider(instance.ProviderType, instance);
}
// create the clients database
this.ClientDatabasesEnsureCreated();
isConfigured = true;
}
}
}
/// <summary>
/// Use this constructor when you are on the Remote Side, only
/// </summary>
public WebProxyServerProvider(CoreProvider localProvider)
{
this.LocalProvider = localProvider;
this.LocalProvider.SyncProgress += (s, e) => this.SyncProgress?.Invoke(s, e);
this.LocalProvider.BeginSession += (s, e) => this.BeginSession?.Invoke(s, e);
this.LocalProvider.EndSession += (s, e) => this.EndSession?.Invoke(s, e);
this.LocalProvider.TableChangesApplied += (s, e) => this.TableChangesApplied?.Invoke(s, e);
this.LocalProvider.TableChangesApplying += (s, e) => this.TableChangesApplying?.Invoke(s, e);
this.LocalProvider.TableChangesSelected += (s, e) => this.TableChangesSelected?.Invoke(s, e);
this.LocalProvider.TableChangesSelecting += (s, e) => this.TableChangesSelecting?.Invoke(s, e);
this.LocalProvider.SchemaApplied += (s, e) => this.SchemaApplied?.Invoke(s, e);
this.LocalProvider.SchemaApplying += (s, e) => this.SchemaApplying?.Invoke(s, e);
this.LocalProvider.DatabaseApplied += (s, e) => this.DatabaseApplied?.Invoke(s, e);
this.LocalProvider.DatabaseApplying += (s, e) => this.DatabaseApplying?.Invoke(s, e);
this.LocalProvider.DatabaseTableApplied += (s, e) => this.DatabaseTableApplied?.Invoke(s, e);
this.LocalProvider.DatabaseTableApplying += (s, e) => this.DatabaseTableApplying?.Invoke(s, e);
this.LocalProvider.ScopeLoading += (s, e) => this.ScopeLoading?.Invoke(s, e);
this.LocalProvider.ScopeSaved += (s, e) => this.ScopeSaved?.Invoke(s, e);
this.LocalProvider.ApplyChangedFailed += (s, e) => this.ApplyChangedFailed?.Invoke(s, e);
}
/// <summary>
/// Default ctor. Using default options and schema
/// </summary>
/// <param name="provider"></param>
public WebServerOrchestrator(CoreProvider provider, WebServerOptions options = null, SyncSetup setup = null)
{
this.Setup = setup ?? new SyncSetup();
this.Options = options ?? new WebServerOptions();
this.Provider = provider;
}
/// <summary>
/// Use this constructor when you are on the Remote Side, only
/// </summary>
public WebProxyServerProvider(CoreProvider localProvider)
{
this.LocalProvider = localProvider;
}
private static async Task SynchronizeAsync(CoreProvider clientProvider)
{
// Database script used for this sample : https://github.com/Mimetis/Dotmim.Sync/blob/master/CreateAdventureWorks.sql
var serverOrchestrator = new WebClientOrchestrator("https://localhost:44342/api/sync");
// Creating an agent that will handle all the process
var agent = new SyncAgent(clientProvider, serverOrchestrator);
try
{
var progress = new SynchronousProgress <ProgressArgs>(args => Console.WriteLine($"{args.PogressPercentageString}:\t{args.Message}"));
// Get the client scope
var scope = await agent.LocalOrchestrator.GetClientScopeAsync();
if (scope.IsNewScope)
{
var client = new HttpClient();
var seedingsResponse = await client.GetAsync($"https://localhost:44342/api/sync/seedings/{scope.Id}");
seedingsResponse.EnsureSuccessStatusCode();
var seedingsResponseString = await seedingsResponse.Content.ReadAsStringAsync();
var seedings = JsonConvert.DeserializeObject <List <Seeding> >(seedingsResponseString);
agent.LocalOrchestrator.OnTableCreating(async tca =>
{
var tableName = tca.TableName.Unquoted().ToString();
var schemaName = string.IsNullOrEmpty(tca.TableName.SchemaName) ? "dbo" : tca.TableName.SchemaName;
var seeding = seedings.FirstOrDefault(s => s.TableName == tableName && s.SchemaName == schemaName);
var id = tca.Table.GetPrimaryKeysColumns().ToList()[0];
if (seeding != null && id.IsAutoIncrement)
{
id.AutoIncrementSeed = seeding.Seed;
id.AutoIncrementStep = seeding.Step;
}
var newTableBuilder = agent.LocalOrchestrator.GetTableBuilder(tca.Table, agent.LocalOrchestrator.Setup);
var newCommand = await newTableBuilder.GetCreateTableCommandAsync(tca.Connection, tca.Transaction);
tca.Command.CommandText = newCommand.CommandText;
});
}
// Launch the sync process
var s1 = await agent.SynchronizeAsync(progress);
// Write results
Console.WriteLine(s1);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("End");
}
public WebProxyServerProvider(CoreProvider localProvider, SerializationFormat serializationFormat)
{
this.LocalProvider = localProvider;
this.serializationFormat = serializationFormat;
this.serializer = BaseConverter <HttpMessage> .GetConverter(this.serializationFormat);
}
/// <summary>
/// Use this constructor when you are on the Remote Side, only
/// </summary>
public WebProxyServerProvider(CoreProvider localProvider) : this(localProvider, SerializationFormat.Json)
{
}
public TestRunner(ProviderFixture providerFixture, CoreProvider serverProvider)
{
this.providerFixture = providerFixture;
this.serverProvider = serverProvider;
}
public CoreBusinessRules()
{
Provider = new CoreProvider();
}
/// <summary> /// Use this constructor when you are on the Remote Side, only /// </summary> public SyncMemoryProvider(CoreProvider localProvider) => this.LocalProvider = localProvider;
public async Task <ProviderRun> RunAsync(CoreProvider serverProvider, ProviderFixture <CoreProvider> serverFixture, string scopeName = null, string[] tables = null, SyncConfiguration conf = null,
bool reuseAgent = true)
{
// server proxy
var proxyServerProvider = new WebProxyServerProvider(serverProvider);
var proxyClientProvider = new WebProxyClientProvider();
var syncTables = tables ?? serverFixture.Tables;
// local test, through tcp
if (this.NetworkType == NetworkType.Tcp)
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(this.ClientProvider, serverProvider, syncTables);
}
// copy conf settings
if (conf != null)
{
serverFixture.CopyConfiguration(this.Agent.Configuration, conf);
}
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f =>
{
if (!this.Agent.Configuration.Filters.Contains(f))
{
this.Agent.Configuration.Filters.Add(f);
}
});
}
// Add Filers values
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
// sync
try
{
this.BeginRun?.Invoke(this.Agent.RemoteProvider);
this.Results = await this.Agent.SynchronizeAsync();
this.EndRun?.Invoke(this.Agent.RemoteProvider);
}
catch (Exception ex)
{
this.Exception = ex;
Console.WriteLine(ex);
}
}
// -----------------------------------------------------------------------
// HTTP
// -----------------------------------------------------------------------
// tests through http proxy
if (this.NetworkType == NetworkType.Http)
{
// client handler
using (var server = new KestrellTestServer())
{
// server handler
var serverHandler = new RequestDelegate(async context =>
{
var syncConfiguration = new SyncConfiguration(syncTables);// set proxy conf
// copy conf settings
if (conf != null)
{
serverFixture.CopyConfiguration(syncConfiguration, conf);
}
// set proxy conf
proxyServerProvider.Configuration = syncConfiguration;
// test if <> directory name works
proxyServerProvider.Configuration.BatchDirectory = Path.Combine(proxyServerProvider.Configuration.BatchDirectory, "server");
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f =>
{
if (!proxyServerProvider.Configuration.Filters.Contains(f))
{
proxyServerProvider.Configuration.Filters.Add(f);
}
});
}
// sync
try
{
this.BeginRun?.Invoke(proxyServerProvider.LocalProvider);
await proxyServerProvider.HandleRequestAsync(context);
this.EndRun?.Invoke(proxyServerProvider.LocalProvider);
}
catch (Exception ew)
{
Console.WriteLine(ew);
}
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(this.ClientProvider, proxyClientProvider);
}
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
((WebProxyClientProvider)this.Agent.RemoteProvider).ServiceUri = new Uri(serviceUri);
try
{
this.Results = await this.Agent.SynchronizeAsync();
}
catch (Exception ew)
{
this.Exception = ew;
Console.WriteLine(ew);
}
});
await server.Run(serverHandler, clientHandler);
}
}
return(this);
}
public MockBaseServerOrchestrator(CoreProvider provider, SyncOptions options, SyncSetup setup, string scopeName = "DefaultScope")
: base(provider, options, setup, scopeName)
{
}
