public void ConfigureTransition(IStateResult result, ISyncState state)
{
Ensure.Argument.IsNotNull(result, nameof(result));
Ensure.Argument.IsNotNull(state, nameof(state));
transitionHandlers.Add(result, _ => state.Start());
}
private List <IAggregateEvent> GetPendingEvents <T>(ISyncState syncState, IList <IAggregateEvent> remoteEvents) where T : class, IAggregateRoot, new()
{
if (syncState.LastSyncedVersion == 0)
{
// if we've never synced, then this aggregate must have been created locally, any events either in
// the event store or from pending commands are pending
return(this.localEventStore.GetAllEvents(syncState.Identity).ToList());
}
// if we have synced the aggregate at least once, then we need to get events from pending commands
var pendingCommandsToExecute = this.pendingCommands.PendingCommandsForAggregate(syncState.Identity).ToList();
if (pendingCommandsToExecute.Count == 0)
{
return(new List <IAggregateEvent>());
}
var aggregate = new T();
aggregate.Identity = syncState.Identity;
((IEventSourced)aggregate).LoadFromEvents(remoteEvents);
var exec = new ExecutingCommandExecutor(aggregate);
exec.Execute(pendingCommandsToExecute, 0);
if (this.snapshotRepository != null && aggregate is ISnapshotSupport)
{
this.snapshotRepository.Save(((ISnapshotSupport)aggregate).GetSnapshot());
}
return(aggregate.UncommittedEvents.ToList());
}
public void ConfigureTransition <T>(StateResult <T> result, ISyncState <T> state)
{
Ensure.Argument.IsNotNull(result, nameof(result));
Ensure.Argument.IsNotNull(state, nameof(state));
transitionHandlers.Add(
result,
t => state.Start(((Transition <T>)t).Parameter)
);
}
public IState <T> AddSyncState(T id, ISyncState <T> syncState)
{
UniTask OnEnter(T from)
{
syncState.OnEnter(from); return(UniTask.CompletedTask);
}
UniTask OnExit(T to)
{
syncState.OnExit(to); return(UniTask.CompletedTask);
}
State <T> state = new State <T>(id, OnEnter, OnExit);
AddState(id, state);
return(state);
}
/// <summary>
/// Merges the existing SyncState into the new state.
/// Merge is done by adding setting the TransferState for files that exist in both SyncStates to the value from "exisitingSyncState"
/// </summary>
/// <returns>Returns 'newSyncState'</returns>
ISyncState MergeSyncStates(ISyncState exisitingSyncState, ISyncState newSyncState)
{
//build dictionary with all files from existing sync state
var filesExisting = exisitingSyncState.Files.ToDictionary(fileItem => fileItem.RelativePath.Trim().ToLower());
//iterate over all files from new sync state
foreach (var fileItem in newSyncState.Files)
{
var key = fileItem.RelativePath.ToLower().Trim();
//if file exists in both states, set TransferState to value from existing sync state
if (filesExisting.ContainsKey(key))
{
fileItem.TransferState.Direction = filesExisting[key].TransferState.Direction;
if (Flags.EnabledExtendedTransferState)
{
fileItem.TransferState.Locations = filesExisting[key].TransferState.Locations;
}
}
}
return(newSyncState);
}
public IState <T> AddState(T id, ISyncState <T> syncState)
{
return(AddSyncState(id, syncState));
}
public void Delete(ISyncState lastSyncState)
{
Storage.Remove(lastSyncState);
}
public void Update(ISyncState syncState)
{
// don't have to do anything as object is modified my reference already
}
protected override void CallMethod(StateResult <object> result, ISyncState <object> factory) => Provider.ConfigureTransition(result, factory);
public void Delete(ISyncState syncState)
{
var ddsSyncState = syncState as DdsSyncState;
_store.Delete(ddsSyncState.Id);
}
public void Update(ISyncState syncState)
{
var ddsSyncState = syncState as DdsSyncState;
_store.Save(ddsSyncState);
}
