public async Task HandleFeedbackToApplicationAsync(IFeedbackToApplication feedback)
{
var handled = await WakekApplication.HandleFeedbackToApplicationReturnSuccessAsync(feedback);
if (handled)
{
return;
}
switch (feedback.Type)
{
case FeedbackType.CommandExecutionCompleted: {
CommandExecutionCompletedHandler(feedback);
} break;
case FeedbackType.CommandsEnabledOrDisabled: {
await CommandsEnabledOrDisabledHandlerAsync();
} break;
default: {
throw new NotImplementedException();
}
}
await Task.CompletedTask;
}
// ReSharper disable once UnusedParameter.Local
private void CommandExecutionCompletedHandler(IFeedbackToApplication feedback)
{
if (!Controller.IsMainThread())
{
return;
}
Cursor = Cursors.Arrow;
}
public async Task HandleFeedbackToApplicationAsync(IFeedbackToApplication feedback)
{
using (SimpleLogger.BeginScope(SimpleLoggingScopeId.Create("Scope"))) {
var methodNamesFromStack = MethodNamesFromStackFramesExtractor.ExtractMethodNamesFromStackFrames();
switch (feedback.Type)
{
case FeedbackType.CommandExecutionCompleted:
case FeedbackType.CommandExecutionCompletedWithMessage: {
await CommandExecutionCompletedHandlerAsync(feedback);
}
break;
case FeedbackType.CommandsEnabledOrDisabled: {
await CommandsEnabledOrDisabledHandlerAsync();
}
break;
case FeedbackType.LogInformation: {
SimpleLogger.LogInformationWithCallStack(feedback.Message, methodNamesFromStack);
}
break;
case FeedbackType.LogWarning: {
SimpleLogger.LogWarningWithCallStack(feedback.Message, methodNamesFromStack);
}
break;
case FeedbackType.LogError: {
SimpleLogger.LogErrorWithCallStack(feedback.Message, methodNamesFromStack);
}
break;
case FeedbackType.CommandIsDisabled: {
SimpleLogger.LogErrorWithCallStack("Attempt to run disabled command " + feedback.CommandType, methodNamesFromStack);
}
break;
case FeedbackType.ImportantMessage: {
var fileName = feedback.Message;
if (File.Exists(fileName))
{
var folder = new Folder(Folder.Text);
fileName = fileName.Substring(folder.FullName.Length + 1);
Results.Items.Add(fileName);
}
}
break;
default: {
throw new NotImplementedException();
}
}
}
await Task.CompletedTask;
}
internal async Task RecordApplicationFeedbackAsync(IFeedbackToApplication feedback)
{
if (feedback.Type == FeedbackType.CommandsEnabledOrDisabled)
{
CommandsEnabledOrDisabledWasReported = true;
}
lock (FeedbacksToApplicationLock) {
FeedbacksToApplication.Add(feedback);
}
await Task.CompletedTask;
}
private async Task CommandExecutionCompletedHandlerAsync(IFeedbackToApplication feedback)
{
if (!Controller.IsMainThread())
{
return;
}
Cursor = Cursors.Arrow;
if (feedback.CommandType == typeof(SearchCommand))
{
await Controller.EnableCommandAsync(typeof(SelectFolderCommand));
}
else if (feedback.CommandType == typeof(SelectFolderCommand))
{
await Controller.EnableCommandAsync(typeof(SearchCommand));
}
}
public void ApplicationFeedbackHandler(IFeedbackToApplication feedBack)
{
if (!CommandController.IsMainThread())
{
throw new ThreadStateException("Feedback handler must only be called on the UI thread");
}
string threadInfo;
switch (feedBack.Type)
{
case FeedbackType.ImportantMessage:
case FeedbackType.MessageOfNoImportance:
case FeedbackType.CommandExecutionCompleted: {
threadInfo = CommandController.IsMainThread() ? "MAIN" : Thread.CurrentThread.ManagedThreadId.ToString();
Output.Text += "\r\n" + threadInfo + ": " + (feedBack.Type == FeedbackType.CommandExecutionCompleted ? "Done" : feedBack.Message);
} break;
case FeedbackType.EnableCommand:
case FeedbackType.DisableCommand: {
throw new ArgumentException("Enable/disable command should be handled by the application command controller");
}
case FeedbackType.MessagesOfNoImportanceWereIgnored: {
threadInfo = CommandController.IsMainThread() ? "MAIN" : Thread.CurrentThread.ManagedThreadId.ToString();
Output.Text += "\r\n" + threadInfo + ": ...";
} break;
case FeedbackType.CommandIsDisabled: {
threadInfo = CommandController.IsMainThread() ? "MAIN" : Thread.CurrentThread.ManagedThreadId.ToString();
Output.Text += "\r\n" + threadInfo + ": COMMAND IS DISABLED";
}
break;
case FeedbackType.CommandsEnabledOrDisabled: {
DoSomething.IsEnabled = CommandController.Enabled(typeof(DoSomethingCommand));
PrimeNumbers.IsEnabled = CommandController.Enabled(typeof(PrimeNumbersCommand));
}
break;
default: {
throw new NotImplementedException();
}
}
}
public async Task ReportAsync(IFeedbackToApplication feedback)
{
switch (feedback.Type)
{
case FeedbackType.EnableCommand: {
await EnableCommandAsync(feedback.CommandType);
} break;
case FeedbackType.DisableCommand: {
await DisableCommandAsync(feedback.CommandType);
} break;
case FeedbackType.MessageOfNoImportance: {
await ReportAsync(feedback.Message, true);
} break;
default: {
await HandleApplicationFeedbackAsync(feedback);
} break;
}
}
internal bool IsFeedbackEqualToRecordedFeedback(ApplicationCommandControllerTestExecutionContext context, IFeedbackToApplication feedback, int i)
{
return(feedback.Type == context.FeedbacksToApplication[i].Type &&
feedback.Message == context.FeedbacksToApplication[i].Message &&
feedback.CommandType == context.FeedbacksToApplication[i].CommandType);
}
public async Task <bool> HandleFeedbackToApplicationReturnSuccessAsync(IFeedbackToApplication feedback)
{
var handled = true;
switch (feedback.Type)
{
case FeedbackType.ImportantMessage: {
XmlSerializedObjectReader.IdentifyType(feedback.Message, out handled, out var feedbackSerializedObjectType);
if (!handled)
{
return(false);
}
if (feedbackSerializedObjectType == typeof(BenchmarkExecution))
{
var benchmarkExecution = XmlSerializedObjectReader.Read <BenchmarkExecution>(feedback.Message);
ReplaceOrAddToCollection(benchmarkExecution, BenchmarkExecutions);
}
else if (feedbackSerializedObjectType == typeof(BenchmarkExecutionState))
{
var benchmarkExecutionState = XmlSerializedObjectReader.Read <BenchmarkExecutionState>(feedback.Message);
ReplaceOrAddToCollection(benchmarkExecutionState, BenchmarkExecutionStates);
}
else
{
handled = false;
}
// ReSharper disable once SeparateControlTransferStatement
} break;
case FeedbackType.LogInformation: {
Log.Add(new LogEntry {
Message = feedback.Message, CreatedAt = feedback.CreatedAt, SequenceNumber = feedback.SequenceNumber
});
} break;
case FeedbackType.LogWarning: {
Log.Add(new LogEntry {
Class = LogEntryClass.Warning, Message = feedback.Message, CreatedAt = feedback.CreatedAt, SequenceNumber = feedback.SequenceNumber
});
} break;
case FeedbackType.LogError: {
Log.Add(new LogEntry {
Class = LogEntryClass.Error, Message = feedback.Message, CreatedAt = feedback.CreatedAt, SequenceNumber = feedback.SequenceNumber
});
} break;
case FeedbackType.CommandIsDisabled: {
Log.Add(new LogEntry {
Class = LogEntryClass.Error, Message = "Attempt to run disabled command " + feedback.CommandType, CreatedAt = feedback.CreatedAt, SequenceNumber = feedback.SequenceNumber
});
} break;
default: {
handled = false;
} break;
}
return(await Task.FromResult(handled));
}
public async Task HandleFeedbackToApplicationAsync(IFeedbackToApplication feedback)
{
await HandleFeedbackToApplicationReturnSuccessAsync(feedback);
}
public async Task <bool> HandleFeedbackToApplicationReturnSuccessAsync(IFeedbackToApplication feedback)
{
return(await WrappedWakekApplication.HandleFeedbackToApplicationReturnSuccessAsync(feedback));
}
public async Task ReportAsync(IFeedbackToApplication feedback)
{
Feedback.Add(feedback);
await Task.CompletedTask;
}
