public async Task <IActionResult> Get([FromRoute][Required] ListarVersoesVeiculoRequest request)
{
var ListarVersoesVeiculoInput = new ListarVersoesVeiculoInput(request.IdModelo);
await _listarVersoesVeiculoUseCase.Execute(ListarVersoesVeiculoInput);
return(_listarModelosPresenter.ViewModel);
}
public async Task <IActionResult> GetCustomer([FromRoute][Required] GetCustomerDetailsRequest request)
{
var getCustomerDetailsInput = new GetCustomerDetailsInput(request.CustomerId);
await _getCustomerDetailsUseCase.Execute(getCustomerDetailsInput);
return(_presenter.ViewModel);
}
public ActionResult <TodoItemViewModel> Post([FromBody] string value)
{
var request = new Core.Boundaries.Todo.Request(value);
_todoUseCase.Execute(request);
return(_todoPresenter.BuildResponse(this));
}
public async Task <IActionResult> Post([FromBody][Required] IncluirAnuncioRequest request)
{
var IncluirAnuncioInput = new IncluirAnuncioInput(request.IdMarca, request.IdModelo, request.IdVersao, request.Ano, request.Quilometragem, request.Observacao);
await _IncluirAnuncioUseCase.Execute(IncluirAnuncioInput);
return(_incluirAnuncioPresenter.ViewModel);
}
public async Task <IActionResult> Get([FromRoute][Required] ConsultarAnuncioRequest request)
{
var consultarAnuncioInput = new ConsultarAnuncioInput(request.IdAnuncio);
await _consultarAnuncioUseCase.Execute(consultarAnuncioInput);
return(_consultarAnuncioPresenter.ViewModel);
}
public async Task <IActionResult> Get([FromRoute][Required] GetAccountDetailsRequestV2 request)
{
var getAccountDetailsInput = new GetAccountDetailsInput(request.AccountId);
await _getAccountDetailsUseCase.Execute(getAccountDetailsInput);
return(_presenter.ViewModel);
}
public async Task <IActionResult> Close([FromRoute][Required] CloseAccountRequest request)
{
var closeAccountInput = new CloseAccountInput(request.AccountId);
await _closeAccountUseCase.Execute(closeAccountInput);
return(_presenter.ViewModel);
}
public ActionResult <TodoItemViewModel> Post([FromBody] string value)
{
var request = new Core.Boundaries.AddTodoItem.Request(value);
_addTodoItem.Execute(request);
return(CreatedAtAction(nameof(Post), new { id = _presenter.CreatedItem.Id }, _presenter.CreatedItem));
}
public async Task <IActionResult> Post([FromBody] LoginRequest request)
{
await loginUseCase.Execute(new Input(
new Name(request.Name),
new Password(request.Password)));
return(presenter.ViewModel);
}
public ActionResult Post(EventDto myEvent)
{
var @convertedEvent = myEvent.ConvertToDomain(_eventFactory);
var @event = _postEvent.Execute(convertedEvent);
_inviteUseCase.Execute(new InvitationInput(myEvent.SentInvitations, @event.Id));
return(CreatedAtAction(nameof(GetById), new { id = @event.Id }, @event));
}
public async Task <IActionResult> Post([FromBody] RegisterRequest request)
{
await _registerUseCase.Execute(new Input(
new SSN(request.SSN),
new Name(request.Name),
new PositiveAmount(request.InitialAmount)));
return(_presenter.ViewModel);
}
public async Task <IActionResult> Refund([FromBody][Required] RefundRequest request)
{
var refundInput = new RefundInput(
request.AccountId,
new PositiveMoney(request.Amount)
);
await _refundUseCase.Execute(refundInput);
return(_presenter.ViewModel);
}
public async Task <IActionResult> Withdraw([FromBody][Required] WithdrawRequest request)
{
var withdrawInput = new WithdrawInput(
request.AccountId,
new PositiveMoney(request.Amount)
);
await _withdrawUseCase.Execute(withdrawInput);
return(_presenter.ViewModel);
}
public async Task <IActionResult> Get(int limit = 10, int offset = 0)
{
var response = await _readReportsUseCase.Execute(new ReadReportsRequest
{
Limit = limit,
Offset = offset
});
return(Ok(response));
}
public void Run(string[] args)
{
try
{
OnStart();
if (ShowHeader)
{
applicationHeader?.Display();
}
Arguments arguments = new Arguments(args);
IUseCase useCase = useCases.SelectCommand(arguments.Command);
if (UseSpinner)
{
Spinner.Run(() => useCase.Execute(arguments));
}
else
{
useCase.Execute(arguments);
}
}
catch (Exception ex)
{
OnError(ex);
}
finally
{
OnExit();
if (ShowFooter)
{
applicationFooter?.Display();
}
if (PauseOnExit)
{
Pause.QuickDisplay();
}
}
}
public async Task <IActionResult> Transfer([FromBody][Required] TransferRequest request)
{
await _TransferUseCase.Execute(
new TransferInput(
request.OriginAccountId,
request.DestinationAccountId,
new PositiveAmount(request.Amount)
));
return(_presenter.ViewModel);
}
public async Task <IActionResult> Post(ReportModel model)
{
var useCaseRequest = new CreateReportRequest
{
Model = model
};
var response = await _createReportUseCase.Execute(useCaseRequest);
return(response.Data.Match <IActionResult>(item => Ok(item), item => BadRequest(item)));
}
public void Peut_replanifier_un_entretien()
{
IUseCase <Entretien> sut = new ReplanifierUnEntretien(genMock.Object, creneau2);
IEnumerable <Entretien> entretiens = new List <Entretien>();
entretiens = planifierUnEntretien.Execute(entretiens.ToList());
entretiens = sut.Execute(entretiens.ToList());
Assert.That(entretiens.Count(), Is.EqualTo(1));
Assert.That(entretiens.First().statut, Is.EqualTo(EntretienStatut.Replanifier));
}
public async Task <IActionResult> Deposit([FromBody][Required] DepositRequest request)
{
var depositInput = new DepositInput(
request.AccountId,
new PositiveMoney(request.Amount)
);
await _depositUseCase.Execute(depositInput);
return(_presenter.ViewModel);
}
public void AddTodoItem(string[] args)
{
if (args.Length != 2)
{
return;
}
var input = new TodoList.Core.Boundaries.AddTodoItem.Request(args[1]);
_addTodoItem.Execute(input);
}
public async Task <IActionResult> Post([FromBody][Required] RegisterRequest request)
{
var registerInput = new RegisterInput(
new SSN(request.SSN),
new Name(request.Name),
new PositiveMoney(request.InitialAmount)
);
await _registerUseCase.Execute(registerInput);
return(_presenter.ViewModel);
}
public void Annule_un_entretien()
{
IEnumerable <Entretien> entretiens = new List <Entretien>();
entretiens = planifierUnEntretien.Execute(entretiens.ToList());
AnnulerUnEntretien annulerUnEntretien = new AnnulerUnEntretien(genMock.Object, "parce que j'en ai envie");
entretiens = annulerUnEntretien.Execute(entretiens.ToList());
Assert.That(entretiens.Count(), Is.EqualTo(1));
Assert.That(entretiens.First().statut, Is.EqualTo(EntretienStatut.Annuler));
}
public async Task <IActionResult> Put(int id, ReportModel model)
{
var request = new UpdateReportRequest
{
ReportId = id,
Model = model
};
var response = await _updateReportUseCase.Execute(request);
return(response.Data.Match <IActionResult>(item => Ok(item), item => BadRequest(item)));
}
public async Task <Object> Registerapplicationuser([FromBody] SignUpModel model)
{
if (ModelState.IsValid)
{
await UseCase.Execute(new Input(model.UserName, model.Email, model.password, model.PhoneNumber));
return(Presenter.ViewModel);
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Get(
[FromServices] IUseCase useCase,
[FromQuery] string owner)
{
if (dummySettings.IsOpenToGetTodos)
{
await useCase.Execute(owner);
return(getTodoPresenter.ViewModel);
}
else
{
return(Ok(new { message = "Today is not opened to get todos." }));
}
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
var transaction = await _pendingToByUseCase.Execute(new EmptyParameter());
Products.ReplaceRange(transaction.Result);
IsBusy = false;
}
public void Clean()
{
int numCommands = Convert.ToInt32(Console.ReadLine());
string positionText = Console.ReadLine();
Position initialPosition = new Position(
Convert.ToInt32(positionText.Split(' ') [0]),
Convert.ToInt32(positionText.Split(' ') [1]));
Command[] commands = new Command[numCommands];
for (int i = 0; i < commands.Length; i++)
{
string commandText = Console.ReadLine();
Direction direction = Direction.North;
if (commandText.Split(' ') [0] == "N")
{
direction = Direction.North;
}
if (commandText.Split(' ') [0] == "S")
{
direction = Direction.South;
}
if (commandText.Split(' ') [0] == "E")
{
direction = Direction.East;
}
if (commandText.Split(' ') [0] == "W")
{
direction = Direction.West;
}
commands[i] = new Command(
Convert.ToInt32(commandText.Split(' ') [1]),
direction);
}
var input = new Request(initialPosition, commands);
_clean.Execute(input);
}
public void UpdateTodoItem(string[] args)
{
if (args.Length != 3)
{
return;
}
Guid id;
if (!Guid.TryParse(args[1], out id))
{
return;
}
var input = new TodoList.Core.Boundaries.UpdateTitle.Request(id, args[2]);
_updateTitle.Execute(input);
}
public async Task <IActionResult> GetCustomer(string customerId)
{
await _getCustomerDetailsUseCase.Execute(new Input(customerId));
return(_presenter.ViewModel);
}
public async Task <IActionResult> Withdraw([FromBody] WithdrawRequest request)
{
await _withdrawUseCase.Execute(new Input(request.AccountId, new PositiveAmount(request.Amount)));
return(_presenter.ViewModel);
}
