public IActionResult Put(int id, Medico medicoAtualizado)
{
try
{
Medico medicoBuscado = _medicoRepository.BuscarPorId(id);
if (medicoBuscado != null)
{
Medico medicoCRM = _medicoRepository.BuscarPorCRM(medicoAtualizado.Crm);
if (medicoCRM == null)
{
_medicoRepository.Atualizar(id, medicoAtualizado);
return(StatusCode(204));
}
return(BadRequest("Não foi possível cadastrar, CRM já existente!"));
}
return(NotFound("Médico não encontrado!"));
}
catch (Exception codErro)
{
return(BadRequest(codErro));
}
}
public IActionResult Put(int id, Medico medicoAtualizado)
{
Medico medicoBuscado = _medicoRepository.BuscarPorId(id);
// Verifica se medicoBuscado é diferente de nulo
if (medicoBuscado != null)
{
//Haverá uma tentativa de atulizar a especialidade
try
{
//Caso seja, o medico será atualizado
_medicoRepository.Atualizar(id, medicoAtualizado);
//E retornará um StatusCode Ok
return(StatusCode(200));
}
//Ao tentar atualizar, se não for possível, retornará um StatusCode com erro
catch (Exception erro)
{
return(BadRequest(erro));
}
}
//Se medico não for diferente de nulo, retornará um StatusCode NotFound
return(StatusCode(404));
}
public IActionResult Post([FromBody] Medico medico)
{
try
{
medico.Validate();
if (!medico.EhValido)
{
return(BadRequest(medico.ObterMensagensValidacao()));
}
var medicoCadastrado = _medicoRepository.ObterTodos(medico.Crm);
if (medicoCadastrado != null)
{
return(BadRequest("Médico já cadastrado no sistema."));
}
if (medico.IdMedico > 0)
{
_medicoRepository.Atualizar(medico);
}
else
{
_medicoRepository.Adicionar(medico);
}
return(Created("api/medico", medico));
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public async Task <Medico> Atualizar(Medico medico)
{
if (!ValidarAtualizacao(medico))
{
return(null);
}
var medicoBanco = _medicoRepository.ObterPorId(medico.Id).Result;
if (medicoBanco == null)
{
_notificacador.NotificarErro("Atualizar Médico", "Id do médico inválido!");
return(null);
}
medicoBanco.AtualizarNome(medico.Nome);
medicoBanco.AtualizarCRM(medico.CRM);
medicoBanco.AtualizarCPF(medico.CPF);
medicoBanco.Especialidades.Clear();
medicoBanco.AdicionarEspecialidades(medico.Especialidades);
if (!OperacaoValida())
{
return(null);
}
_medicoRepository.Atualizar(medico);
await _medicoRepository.SaveChanges();
return(medico);
}
public Medico AtualizarMedico(Medico medico)
{
var medicoAtualizado = _medicoRepository.Atualizar(medico);
_medicoRepository.Salvar();
return(medicoAtualizado);
}
public async Task Atualizar(Medico medico)
{
if (!ExecutarValidacao(new MedicoValidation(), medico))
{
return;
}
await _medicoRepository.Atualizar(medico);
}
public async Task <IActionResult> Edit(Guid id, MedicoViewModel medicoViewModel)
{
if (id != medicoViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(medicoViewModel));
}
medicoViewModel.CPF = medicoViewModel.CPF.ApenasNumeros();
medicoViewModel.Telefone = medicoViewModel.Telefone.ApenasNumeros();
if ((await _consultaRepository.ObtenhaConsultasMedico(id)).Any(c => c.Data > DateTime.Now))
{
ModelState.AddModelError(string.Empty, "Não é possível editar pois existem consultas futuras na jornada de trabalho alterada.");
return(View(medicoViewModel));
}
if (!await _usuarioService.AtualizeEmail(medicoViewModel.UsuarioId, medicoViewModel.Email))
{
ModelState.AddModelError(string.Empty, "Não foi possível atualizar o email.");
return(View(medicoViewModel));
}
if (!await _usuarioService.AtualizeSenha(medicoViewModel.UsuarioId, medicoViewModel.SenhaAntiga, medicoViewModel.Senha))
{
ModelState.AddModelError(string.Empty, "Não foi possível atualizar a senha.");
return(View(medicoViewModel));
}
var medico = _mapper.Map <Medico>(medicoViewModel);
await _medicoRepository.Atualizar(medico);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Put([FromBody] ToEntityMedicoViewModel medicoViewModel)
{
if (!ModelState.IsValid)
{
_logger.Error($"Erro: {_httpContextAccessor.HttpContext.Connection.RemoteIpAddress} - Parâmetros inválidos.");
return(StatusCode(400, "Parâmetros da chamada inválidos"));
}
try
{
_logger.Information("Inciando o processo de atualização do médico.");
var medico_obtido = _medicoRepository.ObterPorId(medicoViewModel.Id);
if (medico_obtido == null)
{
_logger.Error($"Erro: {_httpContextAccessor.HttpContext.Connection.RemoteIpAddress} - Médico não localizado na base de dados.");
return(StatusCode(404, "Médico inexistente"));
}
var Medico = _mapper.Map <Medico>(medicoViewModel);
if (!_medicoValidator.Validate(Medico).IsValid)
{
_logger.Error($"Erro: {_httpContextAccessor.HttpContext.Connection.RemoteIpAddress} - Entidade inválida.");
return(StatusCode(400, _medicoValidator.Validate(Medico).Errors.ToList()));
}
_medicoRepository.Atualizar(Medico);
return(Ok(new { message = "Médico atualizado com sucesso.", data = Medico }));
}
catch (Exception ex)
{
_logger.Error($"Erro: {_httpContextAccessor.HttpContext.Connection.RemoteIpAddress} - Algo deu errado ao atualizar o médico: {ex.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public void Atualizar(Medico entidade)
{
_medicoRepository.Atualizar(entidade);
}
public IActionResult Atualizar(int id, Medico medico)
{
_medicoRepository.Atualizar(id, medico);
return(StatusCode(200));
}
public IActionResult Atualizar(int id, MedicoViewModel json)
{
_medicoRepository.Atualizar(id, json);
return(Ok("Atualizado"));
}
