/// <summary>
/// Generates a TimeStamp like number representing an ordered transaction number
/// </summary>
/// <param name="metadataengine"></param>
private void GenerateTransactionId(IPersistenceEngine engine)
{
Entity info;
string guid;
IList<Entity> es = engine.Load(SyncUtils.INFO);
if (es.Count == 0)
{
InitializeInfo(engine);
es = engine.Load(SyncUtils.INFO);
}
info = es[0];
guid = Guid.NewGuid().ToString();
do
{
lastTransactionId = info.GetInt32(SyncUtils.TRANSACTION);
info.SetValue(SyncUtils.TRANSACTION, ++lastTransactionId);
info.SetValue(SyncUtils.CLIENTID, guid);
Transaction t = new Transaction(engine.Factory.Model);
t.Serialize(info);
t.Commit(engine, false);
es = engine.Load(SyncUtils.INFO);
if (es.Count == 0)
{
InitializeInfo(engine);
es = engine.Load(SyncUtils.INFO);
}
info = es[0];
} while (info.GetInt32(SyncUtils.TRANSACTION) != lastTransactionId || info.GetString(SyncUtils.CLIENTID) != guid);
}
private void FullDownload(IPersistenceEngine client, IPersistenceEngine server, bool bulk)
{
if (client is SyncEngine)
{
((SyncEngine)client).IgnoreClientMetadata = true;
}
// Contains id translation table
Hashtable translationTable = new Hashtable();
Hashtable reverseTable = new Hashtable();
Transaction t = new Transaction(client.Factory.Model);
StringCollection queries = new StringCollection();
// Creates the list of items to load depending whether filters are set or not
if (filters.Count > 0)
{
queries = filters;
}
else
{
foreach (Model.Entity entity in server.Factory.Model.Entities.Values)
{
// Process only root types as it will load all children
if (entity.Inherit != String.Empty && entity.Inherit != null && server.Factory.Model.Entities.ContainsKey(entity.Inherit))
continue;
queries.Add("from " + entity.Type + " e select e");
}
}
if (Progressed != null)
{
// Returns opaths.Count * 2 so that half the processed is reached once entities are processed
Progressed(this, new ProgressEventArgs(0, "Synchronization started", queries.Count * 2));
}
int position = 0;
// Import all entities
foreach (string filter in queries)
{
if (Progressed != null)
{
// Returns opaths.Count * 2 so that half the processed is reached once entities are processed
ProgressEventArgs args = new ProgressEventArgs(position++, "Processing " + filter, queries.Count * 2);
Progressed(this, args);
if (args.Cancel)
{
return;
}
}
int count = Convert.ToInt32(server.LoadScalar(String.Concat("(", filter, ").Count()")));
// System.Diagnostics.Trace.WriteLine("Processing " + opaths + "(" + count.ToString() + ")");
// Loads a set of entities (span)
if (count > 0)
{
t = new Transaction(client.Factory.Model);
IList<Entity> entities = server.Load(filter);
foreach (Entity e in entities)
{
e.State = State.New;
t.Serialize(e);
}
t.Commit(client, false);
// Retrieves the translated ids
foreach (KeyValuePair<string, string> de in t.NewIds)
{
translationTable.Add(String.Concat(entities[0].Type, ".", de.Key), de.Value);
reverseTable.Add(String.Concat(entities[0].Type, ".", de.Value), de.Key);
}
}
}
if (bulk)
{
t = new Transaction(client.Factory.Model);
}
position = 0;
// Import all relationships
foreach (Model.Entity entity in client.Factory.Model.Entities.Values)
{
if (Progressed != null)
{
ProgressEventArgs args = new ProgressEventArgs(queries.Count + position++, "Processing " + entity.Type + " relationships", queries.Count + client.Factory.Model.Entities.Count);
Progressed(this, args);
if (args.Cancel)
{
return;
}
}
// Process only root types as it will load all children
if (entity.Inherit != String.Empty && entity.Inherit != null)
continue;
foreach (Entity parent in client.Load(entity.Type))
{
foreach (Model.Reference reference in server.Factory.Model.GetInheritedReferences(parent.Type))
{
string uniqueParentKey = String.Concat(entity.Type, ".", parent.Id);
string reversedParentId = reverseTable.Contains(uniqueParentKey) ? reverseTable[uniqueParentKey].ToString() : parent.Id;
string query = String.Concat(entity.Type, "[id('", reversedParentId, "')].", reference.Name);
int count = Convert.ToInt32(server.LoadScalar(String.Concat("count(", query, ")")));
// Loads a set of entities (span)
if (count > 0)
{
if (!bulk)
{
t = new Transaction(client.Factory.Model);
}
IList<Entity> entities = server.Load(query);
foreach (Entity e in entities)
{
string uniqueChildKey = String.Concat(e.Type, ".", e.Id);
string childId = translationTable.Contains(uniqueChildKey) ? translationTable[uniqueChildKey].ToString() : e.Id;
t.PushCommand(new Commands.CreateReferenceCommand(reference, parent, e));
}
if (!bulk)
{
t.Commit(client, false);
}
}
}
}
}
if (bulk)
{
t.Commit(client, false);
}
// Creates a Connection token if the providers permit it
if (client is SyncEngine && server is SyncEngine)
{
Entity connection = GetConnection(((SyncEngine)client).ClientId, (SyncEngine)server);
Transaction it;
Entity info = null;
IPersistenceEngine engine = GetPeerMetadataEngine((SyncEngine)server, Peer.Server);
IList<Entity> infos = engine.Load("from " + SyncUtils.INFO + "i select i");
if (infos.Count > 0)
{
info = infos[0];
}
else
{
info = new Entity(SyncUtils.INFO);
info.SetValue(SyncUtils.TRANSACTION, 0);
info.SetValue(SyncUtils.CLIENTID, String.Empty);
it = new Transaction(engine.Factory.Model);
it.Serialize(info);
it.Commit(engine, false);
}
connection.SetValue(SyncUtils.TRANSACTION, info.GetInt32(SyncUtils.TRANSACTION));
it = new Transaction(engine.Factory.Model);
it.Serialize(connection);
it.Commit(engine, false);
((SyncEngine)client).IgnoreClientMetadata = false;
}
}
