public async Task <ResultDto <AtendimentoDto> > Create(AtendimentoDto atendimentoDto)
{
var atendimentoDtoValidate = new AtendimentoDtoValidate(atendimentoDto);
if (!atendimentoDtoValidate.Validate())
{
return(await Task.FromResult(ResultDto <AtendimentoDto> .Validation(atendimentoDtoValidate.Mensagens)));
}
var atendimento = _mapper.Map <Atendimento>(atendimentoDto);
atendimento.SituacaoId = (int)ESituacao.PENDENTE;
atendimento.DataCadastro = DateTime.Now;
await _atendimentoRepository.Create(atendimento);
if (atendimentoDto.AgendamentoId.HasValue)
{
var agendamento = await _agendamentoRepository.ObterPorId(atendimentoDto.AgendamentoId.Value);
agendamento.FinalizarAgendamento();
await _agendamentoRepository.Update(agendamento);
}
return(await Task.FromResult(ResultDto <AtendimentoDto> .Success(_mapper.Map <AtendimentoDto>(atendimento))));
}
private void ValidateAtendimento(AtendimentoDto dto, bool delete)
{
if (dto.Titulo.IsNullOrEmpty() && !delete)
{
throw new ApplicationException("Atendimento: O campo 'Título' é obrigatório.");
}
}
public void AtualizarAtendimento(AtendimentoDto atendimentoDto)
{
DataAtendimento = DateTime.Parse(atendimentoDto.DataAtendimento);
Observacao = atendimentoDto.Observacao;
Valor = atendimentoDto.Valor;
Desconto = atendimentoDto.Desconto;
ValorTotal = atendimentoDto.ValorTotal;
UserId = atendimentoDto.UserId;
EstabelecimentoId = atendimentoDto.EstabelecimentoId;
}
public bool EditAtendimento(AtendimentoDto dto)
{
var tarefa = (from a in Contexto.Atendimento
where a.Id == dto.Id
select new { a.DataHoraRegistro, a.IdUsuarioRegistro }).FirstOrDefault();
Contexto.Database.ExecuteSqlCommand($@"UPDATE dbo.atendimento
SET Esconder = true, Temporario = false WHERE Id = {dto.Id}" );
SaveAtendimento(dto, tarefa.DataHoraRegistro, tarefa.IdUsuarioRegistro);
return(true);
}
public ActionResult Save(AtendimentoDto model)
{
if (ModelState.IsValid)
{
var Atendimento = new Atendimento();
_Atendimento.Save(model);
return(RedirectToAction("List"));
}
else
{
return(RedirectToAction("Create", model));
}
}
public void TestaCreateComInformacoesObrigatoriasNulas()
{
var atendimentoDto = new AtendimentoDto();
var retorno = _atendimentoService.Create(atendimentoDto);
Assert.IsTrue(retorno.Result.StatusCode == (int)EStatusCode.ERRO_VALIDACAO);
Assert.IsTrue(retorno.Result.Errors.Contains("Informe a data atendimento!"));
Assert.IsTrue(retorno.Result.Errors.Contains("Informe o valor!"));
Assert.IsTrue(retorno.Result.Errors.Contains("Nenhum usuário vinculado!"));
Assert.IsTrue(retorno.Result.Errors.Contains("Nenhum estabelecimento vinculado!"));
Assert.IsTrue(retorno.Result.Errors.Contains("Nenhum serviço vinculado!"));
Assert.IsTrue(retorno.Result.Errors.Count == 5);
}
public async Task <ResultDto <bool> > Update(AtendimentoDto atendimentoDto)
{
var atendimentoDtoValidate = new AtendimentoDtoValidate(atendimentoDto);
if (!atendimentoDtoValidate.Validate())
{
return(await Task.FromResult(ResultDto <bool> .Validation(atendimentoDtoValidate.Mensagens)));
}
var atendimento = await _atendimentoRepository.ObterPorId(atendimentoDto.AtendimentoId);
atendimento.AtualizarAtendimento(atendimentoDto);
var atendimentoItens = _mapper.Map <List <AtendimentoItem> >(atendimentoDto.AtendimentoItens);
atendimento.AtualizarAtendimentoItens(atendimentoItens);
await _atendimentoRepository.Update(atendimento);
return(await Task.FromResult(ResultDto <bool> .Success(true)));
}
public async Task <AtendimentoDto> Salvar(AtendimentoDto atendimentoDto)
{
try
{
Atendimento atendimento = new(atendimentoDto.Id, atendimentoDto.Data, atendimentoDto.Hora, atendimentoDto.ClienteId, atendimentoDto.FuncionarioId, atendimentoDto.ServicoId, atendimentoDto.ValorTotal, atendimentoDto.Desconto, atendimentoDto.ValorComDesconto, atendimentoDto.ValorPago, atendimentoDto.Troco, atendimentoDto.FormaPagamentoId);
Atendimento resultado;
if (atendimentoDto.Id.Equals(0))
{
resultado = await _repositorio.Adicionar(atendimento);
if (resultado is null)
{
throw new Exception("Erro ao cadastrar, contate o administrador do sistema.");
}
else
{
atendimentoDto.Id = resultado.Id;
}
return(atendimentoDto);
}
else
{
resultado = await _repositorio.Atualizar(atendimento);
if (resultado is null)
{
throw new Exception("Erro ao atualizar, contate o administrador do sistema.");
}
return(atendimentoDto);
}
}
catch (Exception)
{
throw;
}
}
public bool SaveAtendimento(AtendimentoDto dto, DateTime?dataHoraRegistro = null, long?idUsuarioRegistro = null)
{
var entity = new Atendimento()
{
IdPasta = dto.IdPasta == 0 ? null : dto.IdPasta,
Titulo = dto.Titulo,
Descricao = dto.Descricao,
IdSituacaoNpj = dto.IdSituacaoNpj,
IdSituacaoProjudi = dto.IdSituacaoProjudi,
IdSituacaoAtendimento = dto.IdSituacaoAtendimento,
IdProcesso = dto.IdProcesso == 0 ? null : dto.IdProcesso,
IdUsuarioRegistro = idUsuarioRegistro ?? SessionUser.IdUsuario,
DataHoraRegistro = dataHoraRegistro ?? DateTime.Now,
DataHoraAlteracao = DateTime.Now,
IdUsuario = SessionUser.IdUsuario,
Temporario = true
};
Contexto.Atendimento.Add(entity);
Contexto.SaveChanges();
return(true);
}
private string SendMessageByKafka(AtendimentoDto atendimento)
{
var config = new ProducerConfig
{
SaslMechanism = SaslMechanism.Plain,
SecurityProtocol = SecurityProtocol.SaslSsl,
BootstrapServers = $"{_configuration.GetSection("Kafka:BootstrapServers").Value}",
SaslPassword = $"{_configuration.GetSection("Kafka:SaslPassword").Value}",
SaslUsername = $"{_configuration.GetSection("Kafka:SaslUsername").Value}",
};
using (var producer = new ProducerBuilder <Null, string>(config).Build())
{
try
{
var message = JsonConvert.SerializeObject(atendimento);
var sendResult = producer
.ProduceAsync("atendimento-virtual", new Message <Null, string> {
Value = message
})
.GetAwaiter()
.GetResult();
_logger.LogInformation($"Mensagem: {sendResult.Value} incluída em{sendResult.TopicPartitionOffset}");
return($"Mensagem '{sendResult.Value}' de '{sendResult.TopicPartitionOffset}'");
}
catch (ProduceException <Null, string> e)
{
Console.WriteLine($"Delivery failed: {e.Error.Reason}");
}
}
return(string.Empty);
}
public IActionResult Post([FromQuery] AtendimentoDto atendimento)
{
return(Created("", SendMessageByKafka(atendimento)));
}
public async Task <ResultDto <AtendimentoDto> > Post([FromBody] AtendimentoDto atendimentoDto)
{
return(await _atendimentoService.Create(atendimentoDto));
}
/// <summary>
/// Salva a edição de um objeto<T>
/// </summary>
public virtual void Update(AtendimentoDto model)
{
_unitOfWork.GetRepository <AtendimentoDto>().Update(model);
}
/// <summary>
/// Salva e retorna o objeto<T> salvo
/// </summary>
public virtual AtendimentoDto SaveGetItem(AtendimentoDto model)
{
_unitOfWork.GetRepository <AtendimentoDto>().Add(model);
return(model);
}
/// <summary>
/// Salva um objeto<T>
/// </summary>
public virtual void Save(AtendimentoDto model)
{
_unitOfWork.GetRepository <AtendimentoDto>().Add(model);
}
public AtendimentoDtoValidate(AtendimentoDto atendimentoDto)
{
_atendimentoDto = atendimentoDto;
Mensagens = new List <string>();
}
public async Task <ResultDto <bool> > Put(int id, [FromBody] AtendimentoDto atendimentoDto)
{
return(await _atendimentoService.Update(atendimentoDto));
}
