Beispiel #1
0
        public async Task <ActionResult> EditarOcorrencia(Guid ocorrenciaId, [FromBody] OcorrenciaPutDto ocorrenciaPutDto)
        {
            if (!ModelState.IsValid)
            {
                return(CustomResponse(ModelState));
            }

            if (ocorrenciaId != ocorrenciaPutDto.Id)
            {
                NotificarErro("Id da request diferente do Id da Entidade!");
                return(CustomResponse(ocorrenciaPutDto));
            }

            OcorrenciaResultDto ocorrenciaResultDto = await _ocorrenciaService.PesquisarOcorrenciaPorId(ocorrenciaId);

            if (ocorrenciaResultDto == null)
            {
                return(NotFound(new
                {
                    success = true,
                    status = 404,
                    mensagem = "A ocorrência informada não foi encontrada!",
                }));
            }

            await _ocorrenciaService.EditarOcorrencia(ocorrenciaPutDto, ocorrenciaResultDto);

            return(CustomResponse(new
            {
                mensagem = "Ocorrência foi editada com sucesso!",
            }));
        }
        // serviços
        private async Task <bool> ValidarUsuarioEOcorrencia(Guid usuarioId, Guid ocorrenciaId, DateTime dataHoraTramite)
        {
            UsuarioViewDto viewDto = await _usuarioRepository.PesquisarUsuarioPorIdAsync(usuarioId);

            if (viewDto == null)
            {
                Notificar("Usuário informado não foi encontrado!");
                return(false);
            }

            OcorrenciaResultDto ocorrenciaResultDto = await _ocorrenciaRepository.PesquisarOcorrenciaPorId(ocorrenciaId);

            if (ocorrenciaResultDto.Equals(null))
            {
                Notificar("Ocorrência informada não foi encontrada!");
                return(false);
            }

            if (dataHoraTramite < DateTime.Parse(ocorrenciaResultDto.DataHoraInicio))
            {
                Notificar("Data/Hota do trâmite informada é menor que Data/Hora inicio da ocorrência!");
                return(false);
            }
            if (!DateTime.Parse(ocorrenciaResultDto.DataHoraFim).Equals(null))
            {
                if (dataHoraTramite > DateTime.Parse(ocorrenciaResultDto.DataHoraFim))
                {
                    Notificar("Data/Hota do trâmite informada é maior que Data/Hora fim da ocorrência!");
                    return(false);
                }
            }

            return(true);
        }
        public async Task <OcorrenciaResultDto> PesquisarOcorrenciaPorInc(int incOcorrencia)
        {
            try
            {
                OcorrenciaResultDto result = await _context.Ocorrencias
                                             .Where(oco => oco.IncOcorrencia == incOcorrencia)
                                             .Include(oco => oco.UsuarioId)
                                             .DefaultIfEmpty()
                                             .Select(oco => new OcorrenciaResultDto
                {
                    Id                        = oco.Id.ToString(),
                    IncOcorrecia              = oco.IncOcorrencia.ToString(),
                    Titulo                    = oco.Titulo,
                    DataHoraInicio            = oco.DataHoraInicio.ToString("dd/MM/yyyy HH:mm:ss"),
                    DataHoraFim               = string.IsNullOrEmpty(oco.DataHoraFim.ToString()) ? null : oco.DataHoraFim.ToString(),
                    DataHoraUltimaAtualizacao = oco.DataHoraUltimaAtualizacao.ToString("dd/MM/yyyy HH:mm:ss"),
                    ChamadoTI                 = oco.ChamadoTI,
                    ChamadoFornecedor         = oco.ChamadoFornecedor,
                    OcorrenciaCCM             = oco.OcorrenciaCCM,
                    Acionamento               = oco.Acionamento ? "SIM" : "NAO",
                    Impacto                   = oco.Impacto ? "SIM" : "NAO",
                    DescricaoImpacto          = oco.DescricaoImpacto,
                    StatusAtualOcorrencia     = oco.StatusAtualOcorrencia.ToString(),
                    UsuarioId                 = oco.UsuarioId.ToString(),
                    DescricaoUsuario          = oco.Usuario.UserName + " - " + oco.Usuario.NomeCompleto,
                }
                                                     ).SingleAsync();

                return(result);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        private async Task <bool> CadastrarTurnoOcorrencia(Guid turnoId, OcorrenciaResultDto ocorrenciaResultDto)
        {
            TurnoOcorrencia turnoOcorrencia = new TurnoOcorrencia(turnoId,
                                                                  Guid.Parse(ocorrenciaResultDto.Id),
                                                                  Enum.Parse <StatusOcorrenciaEnum>(ocorrenciaResultDto.StatusAtualOcorrencia));

            return(await _turnoOcorrenciaRepository.CadastrarTurnoOcorrencia(turnoOcorrencia));
        }
        public async Task <ICollection <TramiteResultDto> > PesquisarTramitePorOcorrencia(Guid ocorrenciaId)
        {
            OcorrenciaResultDto ocorrenciaResultDto = await _ocorrenciaRepository.PesquisarOcorrenciaPorId(ocorrenciaId);

            if (ocorrenciaResultDto == null)
            {
                Notificar("Nenhuma ocorrência foi encontrado com Id informado!");
                return(null);
            }

            return(await _tramiteRepository.PesquisarTramitesPorOcorrencia(ocorrenciaId));
        }
Beispiel #6
0
        public async Task <ActionResult> PesquisarOcorrenciaPorInc(int incOcorrencia)
        {
            OcorrenciaResultDto result = await _ocorrenciaService.PesquisarOcorrenciaPorInc(incOcorrencia);

            if (result == null)
            {
                return(NotFound(new
                {
                    success = true,
                    status = 404,
                    mensagem = "Ocorrência informada não foi encontrada!",
                }));
            }

            return(CustomResponse(result));
        }
 public Ocorrencia(OcorrenciaPutDto ocorrenciaPutDto, OcorrenciaResultDto ocorrenciaResultDto)
 {
     Id                        = Guid.Parse(ocorrenciaResultDto.Id);
     IncOcorrencia             = int.Parse(ocorrenciaResultDto.IncOcorrecia);
     Titulo                    = ocorrenciaPutDto.Titulo;
     DataHoraInicio            = ocorrenciaPutDto.DataHoraInicio;
     DataHoraFim               = ocorrenciaPutDto.DataHoraFim;
     DataHoraUltimaAtualizacao = DateTime.Now;
     ChamadoTI                 = ocorrenciaPutDto.ChamadoTI;
     ChamadoFornecedor         = ocorrenciaPutDto.ChamadoFornecedor;
     ChamadoTI                 = ocorrenciaPutDto.OcorrenciaCCM;
     Acionamento               = ocorrenciaPutDto.Acionamento;
     Impacto                   = ocorrenciaPutDto.Impacto;
     DescricaoImpacto          = ocorrenciaPutDto.DescricaoImpacto;
     StatusAtualOcorrencia     = ocorrenciaPutDto.StatusAtualOcorrencia;
     UsuarioId                 = ocorrenciaPutDto.UsuarioId;
 }
        public async Task <bool> EditarOcorrencia(OcorrenciaPutDto ocorrenciaPutDto, OcorrenciaResultDto ocorrenciaResultDto)
        {
            // validação domínio
            if (!ExecutarValidacao(new OcorrenciaPutDtoValidation(), ocorrenciaPutDto))
            {
                return(false);
            }

            // validação regra de negócio
            if (!await EhDataHoraValida(ocorrenciaPutDto.TurnoId, ocorrenciaPutDto.DataHoraInicio, ocorrenciaPutDto.DataHoraFim))
            {
                return(false);
            }

            if (!await EhTurnoValido(ocorrenciaPutDto.TurnoId))
            {
                return(false);
            }

            if (!await EhUsuarioValido(ocorrenciaPutDto.UsuarioId))
            {
                return(false);
            }

            if (!await EhListaAtivoValida(ocorrenciaPutDto.Ativos))
            {
                return(false);
            }

            Ocorrencia ocorrencia = new Ocorrencia(ocorrenciaPutDto, ocorrenciaResultDto);

            await _ocorrenciaRepository.EditarAsync(ocorrencia);

            await EditarTurnoOcorrencia(ocorrenciaPutDto, Guid.Parse(ocorrenciaResultDto.Id));

            await ExcluirOcorrenciaAtivo(ocorrenciaPutDto.Id);

            await CadastrarOcorrenciaAtivo(ocorrenciaPutDto.Id, ocorrenciaPutDto.Ativos);

            return(true);
        }
Beispiel #9
0
        public async Task <ActionResult> ExcluirOcorrencia(Guid ocorrenciaId)
        {
            OcorrenciaResultDto result = await _ocorrenciaService.PesquisarOcorrenciaPorId(ocorrenciaId);

            if (result == null)
            {
                return(NotFound(new
                {
                    success = false,
                    status = 404,
                    mensagem = "A ocorrência informada não foi encontrada!",
                }));
            }

            await _ocorrenciaService.ExcluirOcorrencia(ocorrenciaId);

            return(CustomResponse(new
            {
                mensagem = "A ocorrência foi excluída com sucesso!",
            }));
        }