private void RespondWithInvalidItemDescription(IRespondWithSuccessOrError <CreateTodoOutput, ErrorOutputMessage> presenter)
{
var errors = new ErrorOutputMessage();
errors.AddError("ItemDescription cannot be empty or null");
presenter.Respond(errors);
}
public void Execute(TestInput inputTo, IRespondWithSuccessOrError <TestResult, ErrorOutput> presenter)
{
var context = new TestContext
{
Value1 = inputTo.a,
Value2 = inputTo.b
};
var sagaWithCompenstate = new SagaBuilder <TestContext>()
.With_Context_State(context)
.Using_Step(new Func <TestContext, Task>(async(ctx) =>
{
await Add_Numbers(ctx);
ctx.AddError("error adding two numbers");
}))
.With_Error_Behavior(Domain.Saga.ErrorBehavior.Terminate) // could be Terminate so saga halts at this step
.Using_Step(new Func <TestContext, Task>(async(ctx) =>
{
await Add_Numbers(ctx);
}))
.With_Finish_Actions((ctx) =>
{
presenter.Respond(new TestResult
{
Result = ctx.Result
});
},
(err) =>
{
presenter.Respond(err);
});
sagaWithCompenstate.Run();
}
public void RespondWithErrorMessage(string message, IRespondWithSuccessOrError <CreateCommentOutput, ErrorOutputMessage> presenter)
{
var errorOutputMessage = new ErrorOutputMessage();
errorOutputMessage.AddError(message);
presenter.Respond(errorOutputMessage);
}
public void Execute(string input, IRespondWithSuccessOrError <string, ErrorOutputTo> presenter)
{
var processStartInfo = _processPipeLineTask.CommandToExecute();
using (var process = _processFactory.CreateProcess(processStartInfo))
{
process.Start();
var outputTask = process.ReadStdOutToEndAsync();
var errorTask = process.ReadStdErrToEndAsync();
process.WriteToStdInput(input);
process.WaitForExit();
var error = errorTask.Result;
if (!string.IsNullOrWhiteSpace(error))
{
var errorOutputTo = new ErrorOutputTo();
errorOutputTo.AddError(error);
presenter.Respond(errorOutputTo);
return;
}
presenter.Respond(outputTask.Result);
}
}
public void Execute(TestInput inputTo, IRespondWithSuccessOrError <TestResult, ErrorOutput> presenter)
{
var context = new TestContext
{
Value1 = inputTo.a,
Value2 = inputTo.b
};
var workflowResult = new SagaBuilder <TestContext>()
.With_Context_State(context)
.Using_Step(_addTask)
.Using_Step(_plusTenTask)
.Using_Step((ctx) =>
{
var input = new TestInput
{
a = ctx.Value1,
b = ctx.Result
};
var propertyPresenter = new PropertyPresenter <TestResult, ErrorOutput>();
_useCase.Execute(input, propertyPresenter);
if (propertyPresenter.IsErrorResponse())
{
throw new Exception();
}
ctx.Result = propertyPresenter.SuccessContent.Result;
})
.With_Finish_Actions(Respond_With_Success(presenter), Respond_With_Error(presenter))
.Run();
}
private static Action <TestContext> Respond_With_Success(IRespondWithSuccessOrError <TestResult, ErrorOutput> presenter) => (TestContext ctx) =>
{
presenter.Respond(new TestResult
{
Result = ctx.Result
});
};
private static void RepsondWithNullFilter(IRespondWithSuccessOrError <List <TodoTo>, ErrorOutputMessage> presenter)
{
var errors = new ErrorOutputMessage();
errors.AddError("Null filter object");
presenter.Respond(errors);
}
public void Execute(TestInput inputTo, IRespondWithSuccessOrError <TestResult, ErrorOutput> presenter)
{
var context = new TestContext
{
Value1 = inputTo.a,
Value2 = inputTo.b
};
var workflowResult = new SagaBuilder <TestContext>()
.With_Context_State(context)
.Using_Step(_addTask)
.Using_Step(_addWithDiTask)
.With_Roll_Back_Action_On_Error((ctx) =>
{
presenter.Respond(new ErrorOutput("Error on step 2"));
})
.With_Finish_Action((ctx) =>
{
presenter.Respond(new TestResult
{
Result = ctx.Result
});
})
.Run();
}
public void Execute(RangedStatsInput inputTo, IRespondWithSuccessOrError <CodeAnalysis, ErrorOutputMessage> presenter)
{
using (var repo = _builder
.WithPath(inputTo.Path)
.WithRange(inputTo.RangeState, inputTo.RangeEnd)
.WithIgnorePatterns(inputTo.IgnorePatterns)
.WithBranch(inputTo.Branch)
.WithWorkingDaysPerWeek(inputTo.DaysPerWeek)
.WithWorkingWeekHours(inputTo.HoursPerWeek)
.WithIgnoreComments(inputTo.IgnoreComments)
.WithAliasMapping(inputTo.AliasFile)
.WithWeekends(inputTo.WeekendDays)
.Build())
{
//var authors = repo.List_Authors();
//var stats = repo.Build_Individual_Developer_Stats(authors);
//var dailyDeveloperStats = repo.Build_Daily_Individual_Developer_Stats(authors);
//var teamStats = repo.Build_Team_Stats();
//var result = new StatsOutput
//{
// Authors = authors,
// DeveloperStats = stats,
// DailyDeveloperStats = dailyDeveloperStats,
// TeamStats = teamStats,
// ReportingRange = repo.ReportingRange
//};
var codeAnalysis = repo.Run_Analysis();
presenter.Respond(codeAnalysis);
}
}
private void Respond_With_File(RenderWordInput inputTo,
IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter,
RenderedDocumentOutput result)
{
var reportMessage = new WordFileOutput(inputTo.ReportName, result.FetchDocumentAsByteArray());
presenter.Respond(reportMessage);
}
private void Respond_With_Errors(IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter,
RenderedDocumentOutput output)
{
var errorOutput = new ErrorOutput();
errorOutput.AddErrors(output.ErrorMessages);
presenter.Respond(errorOutput);
}
public async Task Execute(Cities inputTo, IRespondWithSuccessOrError <int, ErrorOutput> presenter)
{
//Todo: Is this correct?
//Todo: Is there a different way of doing this?
var cityCode = await _country.Fetch_City_Code(inputTo.City, inputTo.State, inputTo.Country);
presenter.Respond(cityCode);
}
private void RespondWithSuccess(IRespondWithSuccessOrError <CreateTodoOutput, ErrorOutputMessage> presenter, CreateTodoOutput output)
{
var outputMessage = new CreateTodoOutput {
Id = output.Id
};
presenter.Respond(outputMessage);
}
private void RenderReport(ReportGenerationArguments arguments,
Func <string, ReportGenerationArguments, NodePipeLineTask> taskFactory,
IRespondWithSuccessOrError <string, ErrorOutput> presenter)
{
var nodeAppPath = Fetch_NodeApp_Path(_options.NodeApp);
var task = taskFactory.Invoke(nodeAppPath, arguments);
var executor = new SynchronousAction(task, new ProcessFactory());
executor.Execute(presenter);
}
public void Execute(TodoFilterInput inputTo, IRespondWithSuccessOrError <List <TodoTo>, ErrorOutputMessage> presenter)
{
if (inputTo == null)
{
RepsondWithNullFilter(presenter);
return;
}
var filteredCollection = FetchFilteredCollection(inputTo);
presenter.Respond(filteredCollection);
}
public void Render(Func <TSuccessInner, TSuccessOuter> conversionFunc, IRespondWithSuccessOrError <TSuccessOuter, TError> presenter)
{
if (_errors != null)
{
presenter.Respond(_errors);
return;
}
var conversionResult = conversionFunc.Invoke(_output);
presenter.Respond(conversionResult);
}
public void Execute(RenderWordInput inputTo,
IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter)
{
var result = _wordGateway.CreateWordReport(inputTo);
if (result.HasErrors())
{
Respond_With_Errors(presenter, result);
return;
}
Respond_With_File(inputTo, presenter, result);
}
public void Execute(RenderPdfInput inputTo,
IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter)
{
var output = _pdfGateway.ConvertToPdf(inputTo);
if (Render_Errors(output))
{
Respond_With_Errors(presenter, output);
return;
}
Respond_With_Pdf(inputTo, presenter, output);
}
public void Execute(RenderExcelInput inputInput,
IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter)
{
var result = _reportGateway.CreateExcelReport(inputInput);
if (result.HasErrors())
{
Respond_With_Errors(presenter, result);
return;
}
Respond_With_File(inputInput, presenter, result);
}
public async Task Execute(Cities inputTo, IRespondWithSuccessOrError <Cities, ErrorOutput> presenter)
{
try
{
var city = await _country.Fetch_City_Code(inputTo.City, inputTo.State, inputTo.Country);
presenter.Respond(city);
}
catch (Exception ex)
{
presenter.Respond(new ErrorOutput(ex.Message));
}
}
public void Execute(CreateTodoInput inputTo, IRespondWithSuccessOrError <CreateTodoOutput, ErrorOutputMessage> presenter)
{
var domainEntity = MapInputToDomainEntity(inputTo);
if (InvalidItemDescription(domainEntity))
{
RespondWithInvalidItemDescription(presenter);
return;
}
var output = Persist(inputTo);
RespondWithSuccess(presenter, output);
}
public async Task Execute(Cities inputTo, IRespondWithSuccessOrError <CurrentWeather, ErrorOutput> presenter)
{
try
{
var city = await _country.Fetch_City_Code(inputTo.City, inputTo.State, inputTo.Country);
var currentWeather = await _weather.Fetch_Weather_For_Today(city.CityId);
presenter.Respond(currentWeather);
}
catch (Exception ex)
{
presenter.Respond(new ErrorOutput(ex.Message));
}
}
public void Execute(TestInput inputTo, IRespondWithSuccessOrError <TestResult, ErrorOutput> presenter)
{
var context = new TestContext
{
Value1 = inputTo.a,
Value2 = inputTo.b
};
var sagaWithoutCompenstate = new SagaBuilder <TestContext>()
.With_Context_State(context)
.Using_Step(_addTask)
.Using_Step(_errorTask)
.With_Finish_Actions((ctx) =>
{
presenter.Respond(new TestResult
{
Result = ctx.Result
});
},
(err) =>
{
presenter.Respond(err);
});
var sagaWithCompenstate = new SagaBuilder <TestContext>()
.With_Context_State(context)
.Using_Step(_addTask)
.With_Error_Behavior(Domain.Saga.ErrorBehavior.Continue) // could be Terminate so saga halts at this step
.Using_Step(_errorTask)
.With_Roll_Back_Action_On_Error((ctx) =>
{
ctx.Result -= 10;
})
.With_Finish_Actions((ctx) =>
{
presenter.Respond(new TestResult
{
Result = ctx.Result
});
},
(err) =>
{
presenter.Respond(err);
});
sagaWithCompenstate.Run();
//sagaWithoutCompenstate.Run();
}
public void Execute(RenderWordInput inputTo, IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter)
{
var wordPresenter = new PropertyPresenter <IFileOutput, ErrorOutput>();
_wordUsecase.Execute(inputTo, wordPresenter);
if (wordPresenter.IsErrorResponse())
{
presenter.Respond(wordPresenter.ErrorContent);
return;
}
var pdfInput = Create_Pdf_Input(wordPresenter);
_pdfUsecase.Execute(pdfInput, presenter);
}
public void Execute(RandomPersonInput inputTo, IRespondWithSuccessOrError <InnerTestObject, ErrorOutput> presenter)
{
if (inputTo.ForceError)
{
var errors = new ErrorOutput();
errors.AddError("Forced error happened");
presenter.Respond(errors);
return;
}
var random = new Random(11223);
presenter.Respond(new InnerTestObject
{
Age = random.Next(inputTo.MinAge, inputTo.MaxAge),
FirstName = "Test",
LastName = "User"
});
}
public void Execute(string input, IRespondWithSuccessOrError <string, ErrorOutput> presenter)
{
var processStartInfo = _processPipeLineTask.CommandToExecute();
try
{
using (var process = _processFactory.CreateProcess(processStartInfo))
{
process.Start();
var readerTask = process.ReadStdOutToEndAsync();
var errorTask = process.ReadStdErrToEndAsync();
process.WriteToStdInput(input);
process.WaitForExit(_processPipeLineTask.ProcessTimeout());
if (process.TimeoutOccured)
{
var errorOutput = new ErrorOutput();
errorOutput.AddError($"The process timed out after waiting [{_processPipeLineTask.ProcessTimeout()}] seconds.");
return;
}
var error = errorTask.Result;
if (HasError(error))
{
var errorOutput = new ErrorOutput();
var trimedArugments = processStartInfo.Arguments.Substring(3);
errorOutput.AddError($"Failed to execute {trimedArugments}");
errorOutput.AddError(error);
presenter.Respond(errorOutput);
return;
}
presenter.Respond(readerTask.Result);
}
}
catch (Exception e)
{
throw new Exception($"Failed to execute [{processStartInfo.FileName}] with [{processStartInfo.Arguments}]", e);
}
}
public void Execute(CreateCommentInput inputTo, IRespondWithSuccessOrError <CreateCommentOutput, ErrorOutputMessage> presenter)
{
var domainEntity = CreateDomainModelFromInput(inputTo);
if (InvalidTodoItemId(domainEntity))
{
RespondWithErrorMessage("Invalid item Id", presenter);
return;
}
if (InvalidComment(domainEntity))
{
RespondWithErrorMessage("Missing comment", presenter);
return;
}
var output = Persist(inputTo);
RespondWithSuccess(output, presenter);
}
private void Respond_With_Pdf(RenderPdfInput inputTo,
IRespondWithSuccessOrError <IFileOutput, ErrorOutput> presenter,
RenderedDocumentOutput output)
{
presenter.Respond(new PdfFileOutput(inputTo.FileName, output.FetchDocumentAsByteArray()));
}
public async Task Execute(string inputTo, IRespondWithSuccessOrError <List <Domain.Classes.Weather>, ErrorOutput> presenter)
{
var res = await _forecasts.FetchForecast(inputTo);
presenter.Respond(res);
}
public void Execute(CountryCodeRequest inputTo, IRespondWithSuccessOrError <string, ErrorOutput> presenter)
{
presenter.Respond(_countryCodes.FetchCountryCode(inputTo));
}