public async Task <ComandaDto> CadastrarAsync(ComandaDto comandaDto)
{
using var dbTransaction = _repository.BeginTransaction(_validador);
if (!await _validador.ValidarAsync(comandaDto))
{
return(null);
}
Comanda comanda = comandaDto.ToEntity();
comanda.Id = _geradorGuidService.GetNexGuid();
foreach (var pedido in comanda.Pedidos)
{
pedido.Id = _geradorGuidService.GetNexGuid();
}
comanda.Prepare();
comanda.DataCadastro = DateTime.Now;
Comanda comandaDb = await _repository.CadastrarAsync(comanda);
ComandaDto dto = comandaDb.ToDto();
await _serviceCache.SalvarAsync(dto.Id, dto);
await _mensageriaService.EnviarAsync(new ComandaCadastroCommand(dto));
return(dto);
}
public async Task NaoDeveEditarCasoPedidoContenhaSituacaoInvalida()
{
IComandaService comandaService = _serviceProvider.GetRequiredService <IComandaService>();
ComandaDto comanda = new ComandaDto
{
Id = Guid.NewGuid(),
Situacao = ComandaSituacao.Aberta
};
foreach (var produto in ProdutoMock.ObterListaDeProdutos())
{
comanda.Pedidos.Add(new ComandaPedidoDto()
{
ProdutoId = produto.Id,
ProdutoNome = produto.Nome,
ProdutoPreco = produto.Preco,
Quantidade = 1,
Situacao = default(ComandaPedidoSituacao)
});
}
var result = await comandaService.CadastrarAsync(comanda);
result.Should().BeNull();
comandaService.MensagensValidacao.Should().NotBeNull(StringHelper.JoinHtmlMensagem(comandaService.MensagensValidacao));
comandaService.MensagensValidacao.Any(c => c == ComandaMessage.SituacaoInvalida).Should().BeTrue();
}
public async Task DeveEditarComandaValido()
{
IComandaService comandaService = _serviceProvider.GetRequiredService <IComandaService>();
ComandaDto comanda = new ComandaDto
{
Id = Guid.NewGuid(),
Situacao = ComandaSituacao.Aberta
};
foreach (var produto in ProdutoMock.ObterListaDeProdutos())
{
comanda.Pedidos.Add(new ComandaPedidoDto()
{
ProdutoId = Guid.NewGuid(),
ProdutoNome = produto.Nome,
ProdutoPreco = produto.Preco,
Quantidade = 1,
Situacao = ComandaPedidoSituacao.Pedido
});
}
var result = await comandaService.EditarAsync(comanda);
result.Should().NotBeNull(StringHelper.JoinHtmlMensagem(comandaService.MensagensValidacao));
}
public async Task <ComandaDto> Criar(ComandaDto dto)
{
var criarComandaCommand = MapperModelAndDto.Map <CriarComandaCommand>(dto);
dto.IDComanda = await Mediator.Send(criarComandaCommand);
return(dto);
}
public async Task NaoDeveCadastarCasoNaoContenhaPedido()
{
IComandaService comandaService = _serviceProvider.GetRequiredService <IComandaService>();
ComandaDto comanda = new ComandaDto
{
Situacao = ComandaSituacao.Aberta
};
var result = await comandaService.CadastrarAsync(comanda);
result.Should().BeNull();
comandaService.MensagensValidacao.Should().NotBeNull(StringHelper.JoinHtmlMensagem(comandaService.MensagensValidacao));
comandaService.MensagensValidacao.Any(c => c == ComandaMessage.PedidoObrigatorio).Should().BeTrue();
}
public IHttpActionResult AfterSend(ComandaDto data)
{
try
{
Log.Debug("ComandaController.AfterSend: Inicio");
// Desarrollo de lógica de apertura
LogData(data);
// Fin de lógica de apertura
Log.Debug("ComandaController.AfterSend: Fin");
return(Ok());
}
catch (Exception e)
{
Log.Fatal("ComandaController.AfterSend", e);
return(InternalServerError());
};
}
public async Task <ComandaDto> Fechar(Guid comandaId)
{
using var dbTransaction = _repository.BeginTransaction(_validador);
if (!_validador.PermiteAlterarSituacao(comandaId))
{
return(null);
}
Comanda comanda = await _repository.FecharAsync(comandaId);
ComandaDto dto = comanda.ToDto();
await _serviceCache.SalvarAsync(dto.Id, dto);
await _mensageriaService.EnviarAsync(new ComandaFecharCommand(dto));
return(comanda?.ToDto());
}
private void LogData(ComandaDto data)
{
Log.Info("Detalle de comanda");
Log.Info(data.ComandaId);
Log.Info(data.Fecha);
Log.Info(data.Hora);
Log.Info(data.Estado);
Log.Info(data.Total);
Log.Info("Detalle de renglones");
if (data.Detalle != null)
{
foreach (var renglon in data.Detalle)
{
string line = $"{renglon.NumeroRenglon};{renglon.CodigoArticulo}; ;{renglon.Cantidad}; ;{renglon.Importe}";
Log.Info(line);
}
}
}
public async Task NaoDeveEditarCasoPedidoNaoContenhaProduto()
{
IComandaService comandaService = _serviceProvider.GetRequiredService <IComandaService>();
ComandaDto comanda = new ComandaDto
{
Id = Guid.NewGuid(),
Situacao = ComandaSituacao.Aberta
};
comanda.Pedidos.Add(new ComandaPedidoDto()
{
Quantidade = 1, Situacao = ComandaPedidoSituacao.Pedido
});
var result = await comandaService.EditarAsync(comanda);
result.Should().BeNull();
comandaService.MensagensValidacao.Should().NotBeNull(StringHelper.JoinHtmlMensagem(comandaService.MensagensValidacao));
comandaService.MensagensValidacao.Any(c => c == ComandaMessage.ProdutoObrigatorio).Should().BeTrue();
}
public async Task <ComandaDto> EditarAsync(ComandaDto comandaDto)
{
using var dbTransaction = _repository.BeginTransaction(_validador);
if (!await _validador.ValidarAsync(comandaDto))
{
return(null);
}
Comanda comanda = comandaDto.ToEntity();
comanda.Prepare();
await _repository.EditarAsync(comanda);
ComandaDto dto = comanda.ToDto();
await _serviceCache.SalvarAsync(dto.Id, dto);
await _mensageriaService.EnviarAsync(new ComandaEditarCommand(dto));
return(dto);
}
private void LogData(ComandaDto data)
{
Log.Info("Detalle de comanda");
Log.Info(data.ComandaId);
Log.Info(data.Fecha);
Log.Info(data.Hora);
Log.Info(data.Estado);
Log.Info(data.Total);
Log.Info("Detalle de renglones");
if (data.Detalle != null)
{
foreach (var renglon in data.Detalle)
{
string line = $"{renglon.NumeroRenglon};{renglon.CodigoArticulo}; ;{renglon.Cantidad}; ;{renglon.Importe}";
Log.Info(line);
}
}
Log.Info("Json Envío a cocina");
var json = new JavaScriptSerializer().Serialize(data);
Log.Info(json);
}
public void CreateNewComanda(ComandaDto comandaDto)
{
comandaService.CreateNew(comandaDto);
}
public async Task <IActionResult> Editar(ComandaDto dto)
{
return(await ExecutarFuncaoAsync(() => _service.EditarAsync(dto)));
}
public ComandaCadastroCommand(ComandaDto comanda)
{
Comanda = comanda;
}
public async Task <bool> Atualizar(ComandaDto dto)
{
var atualizarComandaCommand = MapperModelAndDto.Map <AtualizarComandaCommand>(dto);
return(await Mediator.Send(atualizarComandaCommand));
}
public static Comanda ToEntity(this ComandaDto resource)
{
return(resource == null ? null : Mapper.Map <Comanda>(resource));
}
public ComandaConfirmarCommand(ComandaDto comanda)
{
Comanda = comanda;
}
public ComandaEditarCommand(ComandaDto comanda)
{
Comanda = comanda;
}
public ComandaFecharCommand(ComandaDto comanda)
{
Comanda = comanda;
}
public void UpdateComanda(ComandaDto comandaDto)
{
comandaService.Update(comandaDto);
}
