public async Task <IActionResult> Register([FromBody] EmpresaViewModel model, int version)
{
if (version == 2)
{
return(Response(new { Message = "API V2 não disponível" }));
}
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response());
}
var empresa = Mapper.Map <IncluirEmpresaCommand>(model);
await _mediator.EnviarComando(empresa);
if (!OperacaoValida())
{
return(Response(model));
}
var response = GerarTokenUsuario(new LoginViewModel {
Email = model.Email, Senha = model.Senha
});
return(Response(response));
}
public IActionResult Post(IFormFile image)
{
if (image == null || image.Length == 0)
{
_mediator.PublicarEvento(new DomainNotification("Erro", "Imagem com formato incorreto"));
return(Response());
}
FotoViewModel fotoViewModel = new FotoViewModel
{
Id = Guid.NewGuid()
};
using (Stream stream = image.OpenReadStream())
{
using (var binaryReader = new BinaryReader(stream))
{
var fileContent = binaryReader.ReadBytes((int)image.Length);
fotoViewModel.Imagem = fileContent;
}
}
var fotoCommand = _mapper.Map <AdicionarFotoCommand>(fotoViewModel);
_mediator.EnviarComando(fotoCommand);
fotoCommand.AtribuirImagem(fotoCommand.Imagem);
return(Response(fotoCommand));
}
public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
TempData["Erro"] = "Produto com estoque insuficiente";
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
await _mediatorHandler.EnviarComando(command);
if (OperacaoValida())
{
return(RedirectToAction("Index"));
}
TempData["Erros"] = ObterMensagensErro();
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
public async Task <ActionResult> Registrar(Ordem ordem)
{
if (!ModelState.IsValid)
{
return(CustomResponse());
}
ordem.Id = Guid.NewGuid();
ordem.DataCadastro = DateTime.Now;
var result = await _mediator.EnviarComando(
new RegistrarOrdemCommand(
ordem.Id, ordem.IdSolicitante, ordem.IdSolicitacao,
ordem.CodDepartamento, ordem.Descricao, ordem.Solucao,
ordem.DataCadastro, ordem.DataSolucao));
if (result.IsValid)
{
var solicitacaoResult = await AtualizarSolicitacaoOrdem(ordem);
if (!solicitacaoResult.ValidationResult.IsValid)
{
_ordemRepository.Deletar(ordem);
return(CustomResponse(solicitacaoResult.ValidationResult));
}
return(CustomResponse());
}
foreach (var error in result.Errors)
{
AdicionarErroProcessamento(error.ErrorMessage);
}
return(CustomResponse());
}
public async Task <bool> Post([FromBody] PedidoModel model)
{
try
{
AdicionarPedidoCommand adicionarPedidoCommand = new AdicionarPedidoCommand();
adicionarPedidoCommand.ClienteId = model.Cliente.Id;
await _mediatorHandler.EnviarComando(adicionarPedidoCommand);
foreach (var item in model.Itens)
{
AdicionarItemPedidoCommand adicionarItemPedidoCommand = new AdicionarItemPedidoCommand(item.Produto.Id, item.Quantidade, model.Cliente.Id);
await _mediatorHandler.EnviarComando(adicionarItemPedidoCommand);
}
return(true);
}
catch (DominioException ex)
{
return(false);
}
catch (Exception ex)
{
return(false);
}
}
public async Task <IActionResult> AdicionarItem(Guid id, int quantidade)
{
var produto = await _produtoAppService.ObterPorId(id);
if (produto == null)
{
return(BadRequest());
}
if (produto.QuantidadeEstoque < quantidade)
{
TempData["Erro"] = "Produto com estoque insuficiente";
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
// ClienteId é o cliente logado;
var command = new AdicionarItemPedidoCommand(ClienteId, produto.Id, produto.Nome, quantidade, produto.Valor);
await _mediatorHandler.EnviarComando(command);
if (OperacaoValida())
{
return(RedirectToAction("Index"));
}
// Esse TempData está sendo utilizado porque está dando um Redirect - toda vez que da um Redirect, perde o estado do request anterior, então precisa persistir a mensagem no TempData;
TempData["Erros"] = ObterMensagensErro();
return(RedirectToAction("ProdutoDetalhe", "Vitrine", new { id }));
}
public async Task <IActionResult> Index()
{
var comando = new RegistrarClienteCommand(Guid.NewGuid(), "Lucas", "*****@*****.**", "016.025.560-08");
var resultado = await _mediator.EnviarComando(comando);
return(CustomResponse(resultado));
}
public async Task <IActionResult> Post(CadastrarEntregadorCommand entregadorCommand)
{
var response = await _mediator.EnviarComando(entregadorCommand);
if (!response.IsValid)
{
return(CustomResponse(response));
}
return(CustomResponse(response, StatusCodes.Status201Created));
}
public IActionResult Post([FromBody] ContaViewModel contaViewModel)
{
if (!IsModelStateValid())
{
return(Response());
}
var contaCommand = _mapper.Map <RegistrarContaCommand>(contaViewModel);
_mediator.EnviarComando(contaCommand);
return(Response(contaCommand));
}
public IActionResult Post([FromBody] TarefaViewModel tarefaViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
var tarefaCommand = _mapper.Map <RegistrarTarefaCommand>(tarefaViewModel);
_mediator.EnviarComando(tarefaCommand);
return(Response(tarefaCommand));
}
public async Task <IActionResult> Create(Guid id, int quantidade = 1)
{
var carrinhoViewModel = new CarrinhoViewModel()
{
ProdutoId = id,
Quantidade = quantidade
};
var carrinhoCommand = _mapper.Map <RegistrarCarrinhoCommand>(carrinhoViewModel);
await _mediator.EnviarComando(carrinhoCommand);
return(RedirectToAction("Index", "Carrinho"));
}
public IActionResult Post([FromBody] UsuarioViewModel usuarioViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
var usuarioCommand = _mapper.Map <RegistrarUsuarioCommand>(usuarioViewModel);
_mediator.EnviarComando(usuarioCommand);
return(Response(usuarioCommand));
}
public IActionResult Post([FromBody] EventoViewModel eventoViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
var eventoCommand = _mapper.Map <RegistrarEventoCommand>(eventoViewModel);
_mediator.EnviarComando(eventoCommand);
return(Response(eventoCommand));
}
public IActionResult Post([FromBody] LivroViewModel livroViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
var livroCommand = _mapper.Map <IncluirLivroCommand>(livroViewModel);
_mediator.EnviarComando(livroCommand);
return(Response(livroCommand));
}
public IActionResult Post([FromBody] PessoaViewModel pessoaViewModel)
{
if (!ModelStateValida())
{
return(Response());
}
var command = _mapper.Map <RegistrarPessoaCommand>(pessoaViewModel);
_mediator.EnviarComando(command);
return(Response(command));
}
public IActionResult Post([FromBody] EventoViewModel eventoViewModel)
{
// ssbcvp - voltar aqui - não está caindo exatamente aqui, está caindo em alguma validação genérica de erro no Postman que retorna o "title": "One or more validation errors occurred." com o response 400
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response());
}
var eventoCommand = _mapper.Map <RegistrarEventoCommand>(eventoViewModel);
_mediator.EnviarComando(eventoCommand);
return(Response(eventoCommand));
}
public async Task <IActionResult> Create(ProdutoViewModel produtoViewModel)
{
try
{
var produtoCommand = _mapper.Map <RegistrarProdutoCommand>(produtoViewModel);
await _mediator.EnviarComando(produtoCommand);
return(RedirectToAction("Index", "Produtoes"));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public async Task <ActionResult> NovaSolicitacao(Models.Solicitacao solicitacao)
{
if (!ModelState.IsValid)
{
return(CustomResponse());
}
solicitacao.Id = Guid.NewGuid();
solicitacao.DataCadastro = DateTime.Now;
solicitacao.Status = StatusSolicitacao.Pendente;
return(CustomResponse(await _mediator.EnviarComando(
new RegistrarSolicitacaoCommand(
solicitacao.Id, solicitacao.IdSolicitante, solicitacao.Descricao, solicitacao.CodDepartamento,
solicitacao.Status, solicitacao.DataCadastro))));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClientCommand(Guid.NewGuid(), "Gustavo", "*****@*****.**", "40633700894"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "Thiago", "*****@*****.**", "04776504065"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "Guilherme", "*****@*****.**", "71254661093"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> IndexAsync()
{
var resultado = await _mediatorHandler.EnviarComando
(new RegistrarClienteCommand(Guid.NewGuid(), "marcus", "*****@*****.**", "02096235510"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "Thiago Nishio", "*****@*****.**", "82445421365"));
return(Ok(resultado));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "Pintado", "*****@*****.**", "91216282030"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> Index()
{
var result = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "", "", ""));
return(CustomResponse(result));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "Eduardo", "*****@*****.**", "33030148092"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> Index()
{
var resultado = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(Guid.NewGuid(), "jorge", "*****@*****.**", "30314299076"));
return(CustomResponse(resultado));
}
public IActionResult Post([FromBody] RegistrarContaCorrenteViewModel model)
{
if (!ModelStateValida())
{
return(Response());
}
var contaCorrenteCommand = _mapper.Map <RegistrarContaCorrenteCommand>(model);
_mediator.EnviarComando(contaCorrenteCommand);
if (_notifications.HasNotifications())
{
return(Response(_notifications.GetNotifications()));
}
return(Response());
}
public async Task <IActionResult> Index()
{
var resultado = await mediatorHandler.EnviarComando(new RegistrarClienteCommand(Guid.NewGuid()
, "Douglas"
, "*****@*****.**"
, "39304453879"));
return(CustomResponse(resultado));
}
public async Task <IActionResult> Index()
{
var tarefa = await _mediatorHandler.EnviarComando(
new RegistrarClienteCommand(
Guid.NewGuid(),
"werter",
"*****@*****.**",
"36726916825"));
return(RespostaPersonalizada(tarefa));
}