public void ApplyResolution(ISqlDataStore datastore, ISyncSessionInfo syncSessionInfo)
{
foreach (var mergeResolution in MergeResolutionToApplies)
{
mergeResolution.ApplyResolution(datastore, syncSessionInfo);
}
}
public void DisableAutoIncrement(ISqlDataStore dataStore)
{
if (!HasAutoIncrement)
{
return;
}
dataStore.ExecuteNonQuery(string.Format(CultureInfo.InvariantCulture, "SET IDENTITY_INSERT [{0}] ON;", EntityName));
}
public void ApplyRemoteResolution(ISqlDataStore datastore, ISyncSessionInfo syncSessionInfo)
{
if (RemoteMergeResolution == null)
{
return;
}
RemoteMergeResolution.ApplyResolution(datastore, syncSessionInfo);
}
public AppTestContext(ICompositionRoot root)
{
this.root = root;
this.appContext = root.CreateContext();
this.configurationManager = appContext.Resolve <IConfigurationManager>();
this.cs = configurationManager.GetValue("csSqlDataStore");
var dsProvider = appContext.Resolve <IDataStoreProvider>();
this.dataStore = dsProvider.GetDataStore <ISqlDataStore>(cs);
}
public void SetDatastore(ISqlDataStore value)
{
_datastore = value;
var entityInfo = GetSyncableEntity();
_entitySerialiazer = new EntityChangesetBuilder(entityInfo, _syncSession);
if (entityInfo.IsDeleteTrackEnable)
{
_entityTombstoneSerialiazer = new EntityChangesetBuilder(entityInfo.EntityTombstoneInfo, _syncSession);
}
}
public static EntityChangeset Create(ISqlDataStore dataStore, IEntityInfo syncEntity, ISyncSessionInfo syncSessionInfo)
{
var entityName = syncEntity.GetNameInStore();
var result = new EntityChangeset(entityName)
{
_syncSession = syncSessionInfo
};
result.SetDatastore(dataStore);
return(result);
}
public void ApplyDelete(ISqlDataStore datastore, string entityName, EntityChangesetBuilder entitySerialiazer)
{
try
{
using (var command = entitySerialiazer.ToDelete(datastore, entityName, this))
{
datastore.ExecuteNonQuery(command);
}
}
catch (Exception e)
{
throw new Exception(string.Format("Erreur lors de la suppression {0}. Exception: {1}", this, e));
}
}
public IDbCommand FindExisting(ISqlDataStore dataStore, EntityChange entityChange)
{
const string sqlCommandText = "SELECT * FROM [{0}] WHERE {1}";
var @params = new List <IDataParameter>();
var sqlFactory = dataStore.SqlFactory;
var where = BuildWhereIdentity(entityChange, _entityInfo, sqlFactory, @params);
var select = sqlFactory.CreateCommand();
select.CommandText = string.Format(sqlCommandText, _entityInfo.GetNameInStore(), where);
SetCommandParam(@params, select);
return(select);
}
public void ApplyRemoteResolution(ISqlDataStore dataStore, ISyncSessionInfo syncSessionInfo)
{
if (Conflicts == null || Conflicts.Count == 0)
{
return;
}
foreach (var conflict in Conflicts)
{
conflict.ApplyRemotePreResolution(dataStore, syncSessionInfo);
}
foreach (var conflict in Conflicts)
{
conflict.ApplyRemoteResolution(dataStore, syncSessionInfo);
}
}
public void ApplyRemoteResolution(ISqlDataStore dataStore, ISyncSessionInfo syncSession, ISyncStatProvider statProvider)
{
if (EntitiesConflict == null || EntitiesConflict.Count == 0)
{
return;
}
var progression = new LinearProgression(EntitiesConflict.Count);
statProvider.SetNewState(SyncStates.ApplyRemoteResolution, progression);
foreach (var entityConflict in EntitiesConflict)
{
entityConflict.ApplyRemoteResolution(dataStore, syncSession);
progression.CurrentStepFinished();
}
}
public void ApplyChanges(ISqlDataStore datastore, ISyncStatProvider statProvider, IConflictsManager conflictsManager)
{
if (EntityChangeset.Count == 0)
{
return;
}
var progression = new LinearProgression(EntityChangeset.Count * 3);
statProvider.SetNewState(SyncStates.ApplyingRemoteChange, progression);
var changeSets = new List <ChangeSet>();
foreach (var entityChangeset in EntityChangeset)
{
entityChangeset.SetDatastore(datastore);
var conflic = conflictsManager.CreateEntityConflict(entityChangeset, _syncSessionInfo);
changeSets.Add(new ChangeSet(entityChangeset, conflic, conflictsManager));
}
// Update FK changes before delete
foreach (var entityChange in changeSets)
{
entityChange.ApplyUpdate();
progression.CurrentStepFinished();
}
// Delete FK before delete PK
changeSets.Reverse();
foreach (var entityChange in changeSets)
{
entityChange.ApplyDelete();
progression.CurrentStepFinished();
}
// Insert PK before insert FK
changeSets.Reverse();
foreach (var entityChange in changeSets)
{
entityChange.ApplyInsert();
entityChange.ApplyLastSync();
entityChange.ResolveConflicts(datastore);
progression.CurrentStepFinished();
}
}
public void ApplyInsert(ISqlDataStore datastore, EntityChangesetBuilder entitySerialiazer)
{
try
{
DisableAutoIncrement(datastore);
using (var command = entitySerialiazer.ToInsert(datastore, EntityName, this))
{
datastore.ExecuteNonQuery(command);
}
}
catch (Exception e)
{
throw new Exception(string.Format("Erreur lors de l'insertion {0}. Exception: {1}", this, e));
}
finally
{
RestoreAutoIncrement(datastore);
}
}
public void ApplyResolution(ISqlDataStore datastore, ISyncSessionInfo syncSessionInfo)
{
var entityInfo = datastore.Entities[Entity.EntityName];
var entityChangesetBuilder = new EntityChangesetBuilder(entityInfo, syncSessionInfo);
switch (OperationType)
{
case OperationTypes.Insert:
Entity.ApplyInsert(datastore, entityChangesetBuilder);
break;
case OperationTypes.Update:
Entity.ApplyUpdate(datastore, entityChangesetBuilder);
break;
case OperationTypes.Delete:
Entity.ApplyDelete(datastore, Entity.EntityName, entityChangesetBuilder);
break;
}
}
public void RestoreAutoIncrement(ISqlDataStore datastore)
{
if (!HasAutoIncrement)
{
return;
}
datastore.ExecuteNonQuery(string.Format(CultureInfo.InvariantCulture, "SET IDENTITY_INSERT [{0}] OFF;", EntityName));
var primaryKey = Fields.FirstOrDefault(_ => _.IsPrimaryKey);
if (primaryKey == null)
{
return;
}
var primaryKeyField = primaryKey.Name;
var maxIdDbValue = datastore.ExecuteScalar(string.Format("SELECT MAX({0}) FROM [{1}]", primaryKeyField, EntityName));
var maxId = maxIdDbValue == DBNull.Value ? 1 : (long)maxIdDbValue;
datastore.ExecuteNonQuery(string.Format("ALTER TABLE [{0}] ALTER COLUMN {1} IDENTITY ({2}, 1);", EntityName, primaryKeyField, maxId + 1));
}
public void Init()
{
var datasource = TestContext.CurrentContext.Test.MethodName + ".sdf";
Debug.WriteLine(string.Format("Database is available here:{0}", Path.Combine(TestContext.CurrentContext.WorkDirectory, datasource)));
DataStore = SqlCeFactory.CreateStore(datasource);
if (DataStore.StoreExists)
{
DataStore.DeleteStore();
}
DataStore.AddType <Book>();
DataStore.AddType <BookVersion>();
DataStore.CreateOrUpdateStore();
DataStore.Cache = new EntitiesCache();
BookRepository = new BookRepository(DataStore);
DatastoreNoCache = SqlCeFactory.CreateStore(datasource);
DatastoreNoCache.AddType <Book>();
DatastoreNoCache.AddType <BookVersion>();
NoCachedBookVersionRepository = new BookVersionRepository(DatastoreNoCache);
BookVersionRepository = new BookVersionRepository(DataStore);
}
public SqliteAccessStrategy(ISqlDataStore dataStore)
{
_datastore = dataStore;
}
public XpoDataStoreProxy(string connectionString)
{
dataStoreCore = (ISqlDataStore) XpoDefault.GetConnectionProvider(connectionString, AutoCreateOption.DatabaseAndSchema);
dataLayerCore = new SimpleDataLayer(dataStoreCore);
}
public IDbAccessStrategy CreateDbAccessStrategy(ISqlDataStore sqlDataStore)
{
return(new SqlCeAccessStrategy(sqlDataStore));
}
public ISchemaChecker CreateSchemaChecker(ISqlDataStore sqlDataStore)
{
return(new SqlCeSchemaChecker(sqlDataStore));
}
protected SchemaChecker(ISqlDataStore sqlDataStore)
{
SqlDataStore = sqlDataStore;
}
public EntitiesChangeset(ISqlDataStore dataStore, ISyncSessionInfo syncSessionInfo)
{
_dataStore = dataStore;
EntityChangeset = new List <EntityChangeset>();
SetSyncSession(syncSessionInfo);
}
public SqliteSchemaChecker(ISqlDataStore sqlDataStore)
: base(sqlDataStore)
{
}
public ClientEntitiesChangeset(ISqlDataStore dataStore, ISyncSessionInfo syncSessionInfo)
: base(dataStore, syncSessionInfo)
{
}
public SqlCeAccessStrategy(ISqlDataStore datastore)
{
_entityOrdinal = new Dictionary <string, Dictionary <string, int> >();
_datastore = datastore;
}
public StandardDbAccessStrategy(ISqlDataStore dataStore)
{
_datastore = dataStore;
}
