/// <summary>
/// Processes a sync event.
/// </summary>
/// <param name="sender">The object that raised the event.</param>
/// <param name="eventArgs">Event arguments.</param>
private void HandleSyncAsync(object sender, SyncEventArgs eventArgs)
{
Log.LogTrace("Handling sync event");
var response = eventArgs.Response;
HandleRoomEvents(response.Rooms);
}
private void OnSyncEvent(object sender, SyncEventArgs e)
{
if (_logger.IsTrace)
{
_logger.Trace($"|NetworkTrace| sync event {e.SyncStatus.ToString()} on {e.Peer.Node:s}");
}
if (!_sessions.TryGetValue(e.Peer.SessionId, out ISession session))
{
if (_logger.IsTrace)
{
_logger.Trace($"Sync failed for an unknown session {e.Peer.Node:s} {e.Peer.SessionId}");
}
return;
}
var nodeStatsEvent = GetSyncEventType(e.SyncStatus);
_stats.ReportSyncEvent(session.Node, nodeStatsEvent, new SyncNodeDetails
{
NodeBestBlockNumber = e.NodeBestBlockNumber,
OurBestBlockNumber = e.OurBestBlockNumber
});
if (new[] { SyncStatus.InitFailed, SyncStatus.InitCancelled, SyncStatus.Failed, SyncStatus.Cancelled }.Contains(e.SyncStatus))
{
if (_logger.IsDebug)
{
_logger.Debug($"Initializing disconnect {session} on sync {e.SyncStatus.ToString()} with {e.Peer.Node:s}");
}
session.InitiateDisconnect(DisconnectReason.Other, $"sync failed {e.SyncStatus}");
}
}
void FRowSynchronizer_Synced(object sender, SyncEventArgs <object, object> args)
{
switch (args.Action)
{
case CollectionAction.Added:
break;
case CollectionAction.Removed:
break;
case CollectionAction.Cleared:
break;
case CollectionAction.OrderChanged:
break;
case CollectionAction.Updating:
((ISupportInitialize)FDataGridView).BeginInit();
break;
case CollectionAction.Updated:
((ISupportInitialize)FDataGridView).EndInit();
break;
default:
break;
}
}
void SyncComplete(object sender, SyncEventArgs e)
{
ActionHandler.Busy = false;
ActionHandlerEx.Busy = false;
CommonData common = (CommonData)_context.ValueStack.Values["common"];
common.SyncIsOK = e.OK;
DbEngine.Database.Current.SyncComplete(e.OK);
if (_handler != null)
{
_context.InvokeOnMainThread(() =>
{
_handler.ExecuteStandalone(_scriptEngine.Visitor, new object[] { _state });
_state = null;
_handler = null;
});
}
if (!e.OK)
{
LastError = e.Exception.Message;
_context.HandleException(e.Exception);
}
}
void synchronizer_Synced(object sender, SyncEventArgs <object, object> args)
{
var node = args.TargetItem as MapperTreeNode;
switch (args.Action)
{
case CollectionAction.Added:
if (Added != null)
{
Added(this, node);
}
break;
case CollectionAction.Removed:
if (Removed != null)
{
Removed(this, node);
}
break;
case CollectionAction.OrderChanged:
if (OrderChanged != null)
{
OrderChanged(this);
}
break;
default:
// Ignore
break;
}
}
void LoadComplete(object sender, SyncEventArgs e)
{
_baseActivity.RunOnUiThread(() =>
{
if (!_disposed)
{
if (e.OK)
{
StartApplication();
}
else
{
var ce = e.Exception as ConnectionException;
if (ce != null)
{
ReturnToStartMenu(ce.FriendlyMessage, ce.Report);
}
else
{
HandleException(e.Exception);
var ex = e.Exception as CustomException;
if (ex != null)
{
ReturnToStartMenu(ex.FriendlyMessage, ex.Report);
}
}
}
}
});
}
void synchronizer_Synced(object sender, SyncEventArgs <MapperHierarchyNode, object> args)
{
switch (args.Action)
{
case CollectionAction.Added:
FViewer.UpdateView();
break;
case CollectionAction.Removed:
FViewer.UpdateView();
break;
case CollectionAction.Cleared:
FViewer.UpdateView();
break;
case CollectionAction.OrderChanged:
FViewer.UpdateView();
break;
case CollectionAction.Updating:
FViewer.BeginUpdate();
break;
case CollectionAction.Updated:
FViewer.EndUpdate();
break;
}
}
protected virtual void Sync(SyncEventArgs<UserWithSessionVars> e)
{
var handler = OnChange;
if (handler != null)
{
handler(this, e);
}
}
protected virtual void Sync(SyncEventArgs <UserWithSessionVars> e)
{
var handler = OnChange;
if (handler != null)
{
handler(this, e);
}
}
protected virtual void Sync(SyncEventArgs <IEntity> e)
{
var handler = OnChange;
if (handler != null)
{
handler(this, e);
}
}
public void OnChange(object sender, SyncEventArgs<IEntity> e)
{
//No need for keeping track of the following, signalr solves it using buffering
//Might need it for clients that are disconnected for a long time
//Check which users are currently connected (needs a list of users that should be here?)
//save operations for users that are not connected and send at reconnect?
GlobalHost.ConnectionManager.GetHubContext<ProjectHub>()
.Clients.Group(_user.ActiveProject.ToString())
.onChange(e.Operation, e.Type, e.Item);
}
private async Task <bool> SyncCallback(SyncEventArgs e)
{
var task = await MessageService.ShowConfirmMessage(e.Message);
if (task != MessageDialogResult.Affirmative)
{
return(false);
}
return(true);
}
public void OnChange(object sender, SyncEventArgs <IEntity> e)
{
//No need for keeping track of the following, signalr solves it using buffering
//Might need it for clients that are disconnected for a long time
//Check which users are currently connected (needs a list of users that should be here?)
//save operations for users that are not connected and send at reconnect?
GlobalHost.ConnectionManager.GetHubContext <ProjectHub>()
.Clients.Group(_user.ActiveProject.ToString())
.onChange(e.Operation, e.Type, e.Item);
}
private void Sync_OnComplete(object sender, SyncEventArgs e)
{
Write(e.Message);
if (ContinuousMode == true)
{
Write(string.Format("Continuous mode: next sync at: {0}", DateTime.Now.AddMilliseconds(SyncTimer.Interval).ToString("HH:mm:ss")));
StartTimer();
}
SyncRunning = false;
SaveLastSyncTime();
}
void orderSync_Syncing(object sender, SyncEventArgs e)
{
this.Dispatcher.BeginInvoke(new Action(() =>
{
if (this.tbMessage.LineCount > 10000)
{
this.tbMessage.Text = "";
}
this.tbMessage.AppendText(DateTime.Now + ":" + e.Message + Environment.NewLine);
this.tbMessage.ScrollToEnd();
}));
}
private async Task OnSyncFailed(object sender, SyncEventArgs e)
{
if (_activePeers.TryGetValue(e.Peer.NodeId, out var activePeer) && activePeer.Session != null)
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Initializing disconnect on sync failed with node: {e.Peer.NodeId}");
}
await activePeer.Session.InitiateDisconnectAsync(DisconnectReason.BreachOfProtocol);
}
else
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Sync failed, peer not in active collection: {e.Peer.NodeId}");
}
}
}
void LoadComplete(object sender, SyncEventArgs args)
{
if (args.OK)
{
_controller.BeginInvokeOnMainThread(() => {
OpenStartScreen(true);
UIApplication.SharedApplication.EndBackgroundTask(_backgroundTaskId);
});
}
else
{
CustomException ce = args.Exception as CustomException;
if (ce != null)
{
string msg = ce.FriendlyMessage;
Logon(Settings.ClearCacheOnStart, msg);
}
else
{
HandleException(args.Exception);
}
UIApplication.SharedApplication.EndBackgroundTask(_backgroundTaskId);
}
}
private void teamRepository_OnChange(object sender, SyncEventArgs <IEntity> e)
{
Sync(new SyncEventArgs <IEntity>(e.Operation, e.Item));
}
private void Sync_OnProgress(object sender, SyncEventArgs e)
{
Write(e.Message);
}
protected virtual void repository_OnChange(object sender, SyncEventArgs <IEntity> e)
{
SyncManager.OnChange(sender, e);
}
private void Sync_OnCancelled(object sender, SyncEventArgs e)
{
Write(e.Message);
SyncRunning = false;
}
private void Sync_OnError(object sender, SyncEventArgs e)
{
Write(e.Message);
}
private void SynchronizerOnSyncEvent(object sender, SyncEventArgs e)
{
TestContext.WriteLine(e.SyncEvent);
}
static void _syncManager_SyncBegin(object sender, SyncEventArgs SyncArgs)
{
Console.WriteLine(string.Format("Sync Begin: {0}", SyncArgs.Sync.Name));
}
protected virtual void repository_OnChange(object sender, SyncEventArgs<IEntity> e)
{
SyncManager.OnChange(sender, e);
}
/// <summary>
/// Delete appointments in destination
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="syncMetric"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteDestinationAppointments(CalendarSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary <string, object> destinationCalendarSpecificData, SyncCallback syncCallback)
{
//Updating entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
DestinationCalendarService.CalendarServiceName);
//Getting appointments to isDeleteOperation
CalendarSyncEngine.GetDestEntriesToDelete(syncProfile,
SourceAppointments, DestinationAppointments);
var appointmentsToDelete = CalendarSyncEngine.DestAppointmentsToDelete;
if (syncProfile.SyncMode == SyncModeEnum.OneWay && CalendarSyncEngine.DestOrphanEntries.Any())
{
if (syncProfile.SyncSettings.ConfirmOnDelete && syncCallback != null)
{
var orphanEntries = Environment.NewLine +
string.Join(Environment.NewLine, CalendarSyncEngine.DestOrphanEntries);
//Log Orphan Entries
Logger.Warn("Orphan entries to delete: " + orphanEntries);
var message =
$"Are you sure you want to delete {appointmentsToDelete.Count} orphan entries from {DestinationCalendarService.CalendarServiceName}?{orphanEntries}";
var e = new SyncEventArgs(message, UserActionEnum.ConfirmDelete);
var task = syncCallback(e);
if (task.Result)
{
appointmentsToDelete.AddRange(CalendarSyncEngine.DestOrphanEntries);
}
}
else
{
if (!syncProfile.SyncSettings.DisableDelete)
{
appointmentsToDelete.AddRange(CalendarSyncEngine.DestOrphanEntries);
}
else
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SkipDelete);
}
}
}
//Updating Get entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
//Updating isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
DestinationCalendarService.CalendarServiceName);
//Deleting entries
var deletedAppointments =
DestinationCalendarService.DeleteCalendarEvents(appointmentsToDelete, destinationCalendarSpecificData)
.Result;
var isSuccess = deletedAppointments.IsSuccess;
//Update status if entries were successfully deleted
CalendarSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.DestMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.DestMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedAppointments.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
DestinationAppointments.Remove(appointmentsToDelete[index]);
}
}
return(isSuccess);
}
private async Task <bool> SyncCallback(SyncEventArgs e)
{
var messageDialogResult = await MessageService.ShowConfirmMessage(e.Message);
return(messageDialogResult == MessageDialogResult.Affirmative);
}
