/// <summary>
/// Undoes the action in a background task.
/// </summary>
/// <param name="databaseState">State of the database.</param>
/// <param name="settings">The settings.</param>
/// <param name="actionFinishedCallback">The action finished callback.</param>
public void UndoActionInBackground(DatabaseState databaseState, BackpackPlannerSettings settings, Action<Command> actionFinishedCallback)
{
Task.Run(async () =>
{
await UndoActionAsync(databaseState, settings).ConfigureAwait(false);
actionFinishedCallback?.Invoke(this);
}
);
}
/// <summary>
/// Validates the database state.
/// </summary>
/// <param name="databaseState">The database state.</param>
protected async Task ValidateDatabaseStateAsync(DatabaseState databaseState)
{
if(null == databaseState) {
throw new ArgumentNullException(nameof(databaseState));
}
while(!databaseState.IsInitialized) {
await Task.Delay(1).ConfigureAwait(false);
}
}
/// <summary> /// Does the action. /// </summary> /// <param name="databaseState">State of the database.</param> /// <param name="settings">The settings.</param> public abstract Task DoActionAsync(DatabaseState databaseState, BackpackPlannerSettings settings);
/// <summary>
/// Undoes the action.
/// </summary>
/// <param name="databaseState">State of the database.</param>
/// <param name="settings">The settings.</param>
public virtual async Task UndoActionAsync(DatabaseState databaseState, BackpackPlannerSettings settings)
{
await ValidateDatabaseStateAsync(databaseState).ConfigureAwait(false);
}
protected override void AssertFinalState(AppServices services, ServerState finalServerState, DatabaseState finalDatabaseState)
{
finalDatabaseState.Workspaces
.Should()
.HaveCount(2)
.And.Contain(workspace => workspace.SyncStatus == SyncStatus.RefetchingNeeded);
finalDatabaseState.Projects
.Should()
.HaveCount(1)
.And.Contain(project => project.SyncStatus == SyncStatus.RefetchingNeeded);
finalDatabaseState.Tasks
.Should()
.HaveCount(1)
.And.Contain(task => task.SyncStatus == SyncStatus.RefetchingNeeded);
finalDatabaseState.Tags
.Should()
.HaveCount(3);
finalDatabaseState.Tags.ForEach(tag =>
{
tag.SyncStatus.Should().Be(SyncStatus.RefetchingNeeded);
});
finalDatabaseState.TimeEntries
.Should()
.HaveCount(1)
.And.Contain(te => te.Description == "Time Entry" && te.SyncStatus == SyncStatus.InSync);
}
protected override void AssertFinalState(
AppServices services, ServerState finalServerState, DatabaseState finalDatabaseState)
{
finalDatabaseState.TimeEntries.Should().HaveCount(1);
}
public static RootObjectState <TType, TState> GetFrom(DatabaseState database, Identifier identifier)
{
CheckType(identifier);
return((RootObjectState <TType, TState>)database.GetRoot(identifier));
}
protected override void AssertFinalState(AppServices services, ServerState finalServerState, DatabaseState finalDatabaseState)
{
finalDatabaseState.User.DefaultWorkspaceId.Should().HaveValue();
}
protected override void AssertFinalState(AppServices services, ServerState finalServerState, DatabaseState finalDatabaseState)
{
if (finalServerState.DefaultWorkspace == null)
{
throw new NoDefaultWorkspaceException();
}
var workspace = finalServerState.Workspaces.Single(w => w.Name == "ws2");
finalServerState.Workspaces.Should().HaveCount(2);
finalDatabaseState.Workspaces.Should().HaveCount(2)
.And
.Contain(ws => ws.Id == finalServerState.DefaultWorkspace.Id && ws.SyncStatus == SyncStatus.InSync && !ws.IsInaccessible)
.And
.Contain(ws => ws.Id == workspace.Id && ws.SyncStatus == SyncStatus.InSync && !ws.IsInaccessible);
finalDatabaseState.Clients.Should().HaveCount(1).And.OnlyContain(
client => !client.IsInaccessible && client.SyncStatus == SyncStatus.InSync);
finalDatabaseState.Tags.Should().HaveCount(2).And.OnlyContain(
tag => !tag.IsInaccessible && tag.SyncStatus == SyncStatus.InSync);
finalDatabaseState.Projects.Should().HaveCount(1).And.OnlyContain(
project => !project.IsInaccessible && project.SyncStatus == SyncStatus.InSync);
finalDatabaseState.TimeEntries.Should().HaveCount(2).And.OnlyContain(
timeEntry => !timeEntry.IsInaccessible && timeEntry.SyncStatus == SyncStatus.InSync);
}
public static IEnumerable <RootObjectState <TType, TState> > AllFrom(DatabaseState database)
{
return(database.GetRoots(Instance));
}
protected DatabaseStateException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
_state = (DatabaseState)info.GetValue("State", typeof(DatabaseState));
}
public DatabaseStateException(DatabaseState state)
: base()
{
_state = state;
}
public static SubObjectState <TType, TState> GetFrom(DatabaseState database, Identifier parentIdentifier, Identifier identifier)
{
CheckParentType(parentIdentifier);
CheckType(identifier);
return((SubObjectState <TType, TState>)database.GetChild(parentIdentifier, identifier));
}
public static IEnumerable <SubObjectState <TType, TState> > ChildrenFrom(DatabaseState database, Identifier parentIdentifier)
{
CheckParentType(parentIdentifier);
return(database.GetChildren(parentIdentifier, Instance));
}
public static IEnumerable <SubObjectState <TType, TState> > AllFrom(DatabaseState database)
{
return(database.GetAllChildren(Instance));
}
