public void ValidarFiltro(FiltroInventarioAmbienteModelo filtroInventarioAmbienteModelo)
 {
     if (filtroInventarioAmbienteModelo.CodLocaisInstalacao == null)
     {
         throw new Exception("Existem filtros obrigatórios sem preenchimento!");
     }
 }
        public IHttpActionResult Filtrar([FromBody] FiltroInventarioAmbienteModelo filtroInventarioAmbienteModelo)
        {
            IEnumerable <RascunhoInventarioAmbienteModelo> rascunhoInventarioAmbiente;

            try
            {
                rascunhoInventarioAmbiente = this.rascunhoInventarioAmbienteNegocio.ListarRascunhoInventarioAmbiente(filtroInventarioAmbienteModelo);
            }
            catch (Exception exception)
            {
                throw new Exception(GeradorResponse.GenerateErrorResponseString((int)HttpStatusCode.BadRequest,
                                                                                $"Erro ao listar rascunho de inventário de ambiente!", exception), exception);
            }
            return(Ok(GeradorResponse.GenerateSuccessResponse((int)HttpStatusCode.OK,
                                                              $"Recuperação de rascunho de inventário de ambiente ocorrida com sucesso", rascunhoInventarioAmbiente)));
        }
Esempio n. 3
0
        public IHttpActionResult Filtrar([FromBody] FiltroInventarioAmbienteModelo filtroInventarioAmbienteModelo)
        {
            IEnumerable <InventarioAmbienteModelo> inventarioAmbiente;

            try
            {
                inventarioAmbiente = this.inventariosAmbienteNegocio.ListarInventarioAmbiente(filtroInventarioAmbienteModelo);

                if (!inventarioAmbiente.Any())
                {
                    throw new Exception("Não foram encontrados inventários com o(s) filtro(s) selecionado(s)");
                }
            }
            catch (Exception exception)
            {
                throw new Exception(GeradorResponse.GenerateErrorResponseString((int)HttpStatusCode.BadRequest,
                                                                                $"Erro ao listar inventário de ambiente!", exception), exception);
            }
            return(Ok(GeradorResponse.GenerateSuccessResponse((int)HttpStatusCode.OK,
                                                              $"Recuperação da inventário de ambiente ocorrida com sucesso", inventarioAmbiente)));
        }
        public IEnumerable <RASCUNHO_INVENTARIO_AMBIENTE> ListarRascunhoInventarioAmbiente(FiltroInventarioAmbienteModelo filtroInventarioAmbienteModelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                List <RASCUNHO_INVENTARIO_AMBIENTE> rascunhosDistinct = new List <RASCUNHO_INVENTARIO_AMBIENTE>();
                List <RASCUNHO_INVENTARIO_AMBIENTE> rascunhos         = new List <RASCUNHO_INVENTARIO_AMBIENTE>();
                var resultado = entities.RASCUNHO_INVENTARIO_AMBIENTE

                                .Include(x => x.NR_RASCUNHO_INVENTARIO_AMBIENTE.Select(nr => nr.NR))
                                .Include(x => x.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Select(risco => risco.RISCO))
                                .Include(x => x.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Select(risco => risco.RISCO).Select(tpr => tpr.TIPO_RISCO))
                                .Include(x => x.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Select(risco => risco.EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE));

                if (filtroInventarioAmbienteModelo.CodSeveridade != 0 && filtroInventarioAmbienteModelo.CodSeveridade != null)
                {
                    resultado = resultado.Where(x => x.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Any(y => y.CodSeveridade == filtroInventarioAmbienteModelo.CodSeveridade));
                }

                if (filtroInventarioAmbienteModelo.CodProbabilidade != 0 && filtroInventarioAmbienteModelo.CodProbabilidade != null)
                {
                    resultado = resultado.Where(x => x.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Any(y => y.CodProbabilidade == filtroInventarioAmbienteModelo.CodProbabilidade));
                }

                if (filtroInventarioAmbienteModelo.CodAmbiente != 0 && filtroInventarioAmbienteModelo.CodAmbiente != null)
                {
                    resultado = resultado.Where(a => a.CodAmbiente == filtroInventarioAmbienteModelo.CodAmbiente);
                }

                if (filtroInventarioAmbienteModelo.Riscos != null && filtroInventarioAmbienteModelo.Riscos.Count > 0)
                {
                    foreach (var risco in filtroInventarioAmbienteModelo.Riscos)
                    {
                        resultado = resultado.Where(a => a.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Any(x => x.RISCO.CodRisco == risco));
                    }
                }

                var resultadoQuery = resultado.ToList();


                if (filtroInventarioAmbienteModelo.CodLocaisInstalacao != null && filtroInventarioAmbienteModelo.CodLocaisInstalacao.Count > 0)
                {
                    List <string>           CodLocais = new List <string>();
                    List <LOCAL_INSTALACAO> listaLocaisComInventarios = new List <LOCAL_INSTALACAO>();
                    //Busca todos os locais
                    List <LOCAL_INSTALACAO> locais = entities.LOCAL_INSTALACAO
                                                     .Where(x => x.CodLocalInstalacao != (long)Constantes.LocalInstalacao.SEM_ASSOCIACAO)
                                                     .ToList();

                    foreach (var item in filtroInventarioAmbienteModelo.CodLocaisInstalacao)
                    {
                        var local = entities.LOCAL_INSTALACAO.Where(lc => lc.CodLocalInstalacao == item).FirstOrDefault();
                        if (local != null)
                        {
                            CodLocais.Add(local.CodLocalInstalacao.ToString());
                        }
                        else
                        {
                            throw new Exception($"O local {item} não foi encontrado na base de dados!");
                        }

                        //List<LOCAL_INSTALACAO> locaisFilhos = BuscaFilhosPorNivelExcetoInventario(local.CodLocalInstalacao, entities);

                        //Filtra somente os locais do pai
                        List <LOCAL_INSTALACAO> locaisFilhos = this.BuscaLocaisEFilhos(locais, local);

                        listaLocaisComInventarios.AddRange(locaisFilhos);

                        foreach (var itemLocalComInventario in listaLocaisComInventarios)
                        {
                            CodLocais.Add(itemLocalComInventario.CodLocalInstalacao.ToString());
                        }
                    }

                    List <int> codLocaisInt = new List <int>();

                    foreach (var itemInteiro in CodLocais)
                    {
                        codLocaisInt.Add(Convert.ToInt32(itemInteiro));
                    }

                    foreach (var itemResultado in resultadoQuery)
                    {
                        if (!string.IsNullOrEmpty(itemResultado.CodLocalInstalacao))
                        {
                            var separarLocais = itemResultado.CodLocalInstalacao.Split(',');
                            foreach (var item in separarLocais)
                            {
                                if (codLocaisInt.Contains(Convert.ToInt32(item)))
                                {
                                    rascunhos.Add(itemResultado);
                                }
                            }
                        }
                    }
                }



                if (rascunhos.Count <= 0)
                {
                    rascunhosDistinct = resultadoQuery;
                }

                else
                {
                    rascunhosDistinct = rascunhos.Distinct().ToList();
                }

                return(rascunhosDistinct);
            }
        }
        public IEnumerable <RascunhoInventarioAmbienteModelo> ListarRascunhoInventarioAmbiente(FiltroInventarioAmbienteModelo filtroInventarioAmbienteModelo)
        {
            try
            {
                List <RascunhoInventarioAmbienteModelo> inventarioAmbienteModelo = new List <RascunhoInventarioAmbienteModelo>();

                ValidarFiltro(filtroInventarioAmbienteModelo);

                IEnumerable <RASCUNHO_INVENTARIO_AMBIENTE> inv = this.rascunhoInventarioAmbientePersistencia.ListarRascunhoInventarioAmbiente(filtroInventarioAmbienteModelo);

                if (inv.Count() <= 0)
                {
                    throw new KeyNotFoundException("Rascunho de inventário de ambiente não encontrado.");
                }

                foreach (RASCUNHO_INVENTARIO_AMBIENTE inventario in inv)
                {
                    inventarioAmbienteModelo.Add(MapeamentoRascunhoInventarioAmbiente(inventario, null));
                }

                return(inventarioAmbienteModelo);
            }

            catch (Exception e)
            {
                throw e;
            }
        }
        public IEnumerable <INVENTARIO_AMBIENTE> ListarInventarioAmbiente(FiltroInventarioAmbienteModelo filtroInventarioAmbienteModelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                var resultado = entities.INVENTARIO_AMBIENTE

                                .Include(x => x.NR_INVENTARIO_AMBIENTE.Select(nr => nr.NR))
                                .Include(x => x.RISCO_INVENTARIO_AMBIENTE.Select(sev => sev.SEVERIDADE))
                                .Include(x => x.RISCO_INVENTARIO_AMBIENTE.Select(prob => prob.PROBABILIDADE))
                                .Include(x => x.RISCO_INVENTARIO_AMBIENTE.Select(risco => risco.RISCO))
                                .Include(x => x.RISCO_INVENTARIO_AMBIENTE.Select(risco => risco.RISCO).Select(tpr => tpr.TIPO_RISCO))
                                .Include(x => x.RISCO_INVENTARIO_AMBIENTE.Select(risco => risco.EPI_RISCO_INVENTARIO_AMBIENTE))
                                .Include(x => x.LOCAL_INSTALACAO.Select(peso => peso.PESO))
                                .Include(x => x.LOCAL_INSTALACAO.Select(peso => peso.PERFIL_CATALOGO))
                                .Include(x => x.AMBIENTE)
                                .Where(x => x.Ativo && x.CodInventarioAmbiente != (long)Constantes.InventarioAmbiente.SEM_INVENTARIO);

                if (filtroInventarioAmbienteModelo.CodSeveridade != 0 && filtroInventarioAmbienteModelo.CodSeveridade != null)
                {
                    resultado = resultado.Where(x => x.RISCO_INVENTARIO_AMBIENTE.Any(y => y.CodSeveridade == filtroInventarioAmbienteModelo.CodSeveridade));
                }

                if (filtroInventarioAmbienteModelo.CodProbabilidade != 0 && filtroInventarioAmbienteModelo.CodProbabilidade != null)
                {
                    resultado = resultado.Where(x => x.RISCO_INVENTARIO_AMBIENTE.Any(y => y.CodProbabilidade == filtroInventarioAmbienteModelo.CodProbabilidade));
                }

                if (filtroInventarioAmbienteModelo.CodAmbiente != 0 && filtroInventarioAmbienteModelo.CodAmbiente != null)
                {
                    resultado = resultado.Where(a => a.CodAmbiente == filtroInventarioAmbienteModelo.CodAmbiente);
                }

                if (filtroInventarioAmbienteModelo.Riscos != null)
                {
                    foreach (var risco in filtroInventarioAmbienteModelo.Riscos)
                    {
                        resultado = resultado.Where(a => a.RISCO_INVENTARIO_AMBIENTE.Any(x => x.RISCO.CodRisco == risco));
                    }
                }

                var resultadoQuery = resultado.ToList();

                if (filtroInventarioAmbienteModelo.CodLocaisInstalacao.Count > 0)
                {
                    List <LOCAL_INSTALACAO> listaLocaisComInventarios = new List <LOCAL_INSTALACAO>();

                    foreach (var local in filtroInventarioAmbienteModelo.CodLocaisInstalacao)
                    {
                        var localEnviado = entities.LOCAL_INSTALACAO
                                           .Where(loc => loc.CodLocalInstalacao == local && loc.CodLocalInstalacao != (long)Constantes.LocalInstalacao.SEM_ASSOCIACAO).FirstOrDefault();

                        //Filtra somente os locais do pai
                        List <LOCAL_INSTALACAO> locaisFilhos = this.BuscaLocaisEFilhos(localEnviado, entities);

                        listaLocaisComInventarios.AddRange(locaisFilhos);
                    }

                    resultadoQuery = resultadoQuery.Where(local => local.LOCAL_INSTALACAO.Any(x => listaLocaisComInventarios.Contains(x))).ToList();
                }

                return(resultadoQuery);
            }
        }