public async Task <ActionResult> EditarTurno(Guid turnoId, [FromBody] TurnoPutDto turnoPutDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
if (turnoId != turnoPutDto.Id)
{
NotificarErro("Id da request diferente do Id da Entidade!");
return(CustomResponse(turnoPutDto));
}
TurnoResultDto turnoResultDto = await _turnoService.PesquisarTurnoPorId(turnoId);
if (turnoResultDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O turno informado não foi encontrado!",
}));
}
await _turnoService.EditarTurno(turnoPutDto, turnoResultDto);
return(CustomResponse(new
{
mensagem = "O turno foi editado com sucesso!",
}));
}
public async Task <TurnoResultDto> PesquisarTurnoPorInc(int incTurno)
{
try
{
TurnoResultDto result = await _context.Turnos
.Where(tur => tur.IncTurno == incTurno)
.Include(tur => tur.UsuarioId)
.DefaultIfEmpty()
.Select(tur => new TurnoResultDto
{
Id = tur.Id.ToString(),
IncTurno = tur.IncTurno.ToString(),
DataHoraInicio = tur.DataHoraInicio.ToString("dd/MM/yyyy HH:mm:ss"),
DataHoraFim = tur.DataHoraFim.ToString("dd/MM/yyyy HH:mm:ss"),
StatusTurno = ConverterRetornoEnumString(tur.StatusTurno),
UsuarioId = tur.UsuarioId.ToString(),
DescricaoUsuario = tur.Usuario.UserName + " - " + tur.Usuario.NomeCompleto,
}).SingleAsync();
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <bool> EditarTurno(TurnoPutDto turnoPutDto, TurnoResultDto turnoResultDto)
{
// validação domínio
if (!ExecutarValidacao(new TurnoPutDtoValidation(), turnoPutDto))
{
return(false);
}
// validação regra de negócio
// não precisa validar status, pois há um endpoint especifico para isso
if (!await EhDataHoraValida(AcaoEnum.EDITAR, turnoPutDto.DataHoraInicio, turnoPutDto.DataHoraFim, turnoPutDto.Id))
{
return(false);
}
if (!await EhUsuarioValido(turnoPutDto.UsuarioId))
{
return(false);
}
Turno turno = new Turno(turnoPutDto, turnoResultDto);
return(await _turnoRepository.EditarTurno(turno));
}
public async Task <ActionResult> FecharTurno(Guid turnoId)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
TurnoResultDto turnoResultDto = await _turnoService.PesquisarTurnoPorId(turnoId);
if (turnoResultDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O turno informado não foi encontrado!",
}));
}
await _turnoService.FecharTurno(turnoId);
return(CustomResponse(new
{
mensagem = "O turno foi fechado com sucesso!",
}));
}
public Turno(TurnoPutDto turnoPutDto, TurnoResultDto turnoResultDto)
{
Id = Guid.Parse(turnoResultDto.Id);
IncTurno = int.Parse(turnoResultDto.IncTurno);
DataHoraInicio = turnoPutDto.DataHoraInicio;
DataHoraFim = turnoPutDto.DataHoraFim;
UsuarioId = turnoPutDto.UsuarioId;
}
private async Task <bool> EhTurnoValido(Guid turnoId)
{
TurnoResultDto turnoResultDto = await _turnoRepository.PesquisarTurnoPorId(turnoId);
if (turnoResultDto == null)
{
Notificar("Nenhum turno foi encontrado com Id informado!");
return(false);
}
return(true);
}
private async Task <bool> EhStatusTurnoAberto(Guid turnoId)
{
TurnoResultDto turnoResultDto = await _turnoRepository.PesquisarTurnoPorId(turnoId);
if (Enum.Parse <StatusTurnoEnum>(turnoResultDto.StatusTurno) == StatusTurnoEnum.FECHADO)
{
Notificar("Não é permitido excluir um turno com status FECHADO!");
return(false);
}
return(true);
}
private async Task <bool> ValidarPrazoMaximoReabrirTurno(Guid turnoId)
{
TurnoResultDto turnoResultDto = await _turnoRepository.PesquisarTurnoPorId(turnoId);
DateTime DataHoraAtual = DateTime.Now;
TimeSpan diferencaDataHora = DataHoraAtual.Subtract(DateTime.Parse(turnoResultDto.DataHoraInicio));
if (diferencaDataHora.Days > 1)
{
Notificar("Não é possivel abrir um turno fechado a mais de 24 horas!");
return(false);
}
return(true);
}
public async Task <ActionResult> ReabrirTurno(Guid turnoId)
{
TurnoResultDto turnoResultDto = await _turnoService.PesquisarTurnoPorId(turnoId);
if (turnoResultDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O turno informado não foi encontrado!",
}));
}
await _turnoService.ReabrirTurno(turnoId);
return(CustomResponse(new
{
mensagem = "O turno foi reaberto com sucesso!",
}));
}
public async Task <ActionResult> PesquisarTurnoPorInc(int incTurno)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
TurnoResultDto turnoResultDto = await _turnoService.PesquisarTurnoPorInc(incTurno);
if (turnoResultDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O turno informado não foi encontrado!",
}));
}
return(CustomResponse(turnoResultDto));
}
private async Task <bool> EhDataHoraValida(Guid turnoId, DateTime dataHoraInicioOcorrrencia, DateTime?dataHoraFimOcorrrencia)
{
TurnoResultDto turnoResultDto = await _turnoRepository.PesquisarTurnoPorId(turnoId);
if (turnoResultDto != null)
{
if (dataHoraInicioOcorrrencia < DateTime.Parse(turnoResultDto.DataHoraInicio))
{
Notificar("A Data/Hora inicio da ocorrência não pode ser menor que Data/Hora inicio do turno!");
return(false);
}
if (dataHoraInicioOcorrrencia > DateTime.Parse(turnoResultDto.DataHoraFim))
{
Notificar("A Data/Hora inicio da ocorrência não pode ser maior que Data/Hora fim do turno!");
return(false);
}
if (!dataHoraFimOcorrrencia.Equals(null))
{
if (dataHoraFimOcorrrencia < DateTime.Parse(turnoResultDto.DataHoraInicio))
{
Notificar("A Data/Hora fim da ocorrência não pode ser menor que Data/Hora inicio do turno!");
return(false);
}
if (dataHoraFimOcorrrencia > DateTime.Parse(turnoResultDto.DataHoraFim))
{
Notificar("A Data/Hora fim da ocorrência não pode ser maior que Data/Hora fim do turno!");
return(false);
}
}
}
return(true);
}
