示例#1
0
        public IHttpActionResult Inserir([FromBody] InventarioAmbienteModelo inventarioAmbienteModelo)
        {
            try
            {
                RetornoInsercao resultado = new RetornoInsercao();
                resultado = this.inventariosAmbienteNegocio.InserirInventarioAmbiente(inventarioAmbienteModelo);

                if (resultado.status == true)
                {
                    return(Ok(GeradorResponse.GenerateSuccessResponse((int)HttpStatusCode.OK,
                                                                      $"Inserção do inventário de ambiente ocorrida com sucesso", resultado)));
                }
                else
                {
                    return(Ok(GeradorResponse.GenerateSuccessResponse((int)HttpStatusCode.BadRequest,
                                                                      $"Erro ao inserir inventário de ambiente", resultado)));
                }
            }
            catch (InvalidOperationException exception)
            {
                throw new Exception(GeradorResponse.GenerateErrorResponseString((int)HttpStatusCode.OK,
                                                                                "Inventário de Ambiente não encontrado.", exception), exception);
            }
            catch (Exception exception)
            {
                throw new Exception(GeradorResponse.GenerateErrorResponseString((int)HttpStatusCode.OK,
                                                                                "Erro ao inserir Inventário de Ambiente", exception), exception);
            }
        }
示例#2
0
        public LOG_INVENTARIO_AMBIENTE Inserir(InventarioAmbienteModelo novoInventario, long codInventarioInserido,
                                               DB_LaborSafetyEntities entities = null)
        {
            if (entities == null)
            {
                entities = new DB_LaborSafetyEntities();
            }

            entities.Configuration.AutoDetectChangesEnabled = false;

            #region Insere os dados do log de inventário

            LOG_INVENTARIO_AMBIENTE logInventario = new LOG_INVENTARIO_AMBIENTE();

            logInventario.CodLogTipoOperacao    = (long)Constantes.TipoOperacaoLog.INSERCAO;
            logInventario.CodInventario         = codInventarioInserido;
            logInventario.CodUsuarioModificador = novoInventario.EightIDUsuarioModificador;
            logInventario.DataAlteracao         = DateTime.Now;

            entities.LOG_INVENTARIO_AMBIENTE.Add(logInventario);

            entities.ChangeTracker.DetectChanges();
            entities.SaveChanges();

            entities.Configuration.AutoDetectChangesEnabled = true;

            #endregion

            return(logInventario);
        }
示例#3
0
 public IHttpActionResult Editar([FromBody] InventarioAmbienteModelo inventarioAmbienteModelo)
 {
     try
     {
         this.inventariosAmbienteNegocio.EditarInventarioAmbiente(inventarioAmbienteModelo);
         return(Ok(GeradorResponse.GenerateSuccessResponse((int)HttpStatusCode.OK,
                                                           $"Edição do inventário de ambiente ocorrida com sucesso")));
     }
     catch (InvalidOperationException exception)
     {
         throw new Exception(GeradorResponse.GenerateErrorResponseString((int)HttpStatusCode.BadRequest,
                                                                         "Inventário de Ambiente não encontrado.", exception), exception);
     }
     catch (Exception exception)
     {
         throw new Exception(GeradorResponse.GenerateErrorResponseString((int)HttpStatusCode.BadRequest,
                                                                         "Erro ao editar Inventário de Ambiente", exception), exception);
     }
 }
        public INVENTARIO_AMBIENTE EditarInventarioAmbiente(InventarioAmbienteModelo inventarioAmbienteModelo, DB_LaborSafetyEntities entities)
        {
            INVENTARIO_AMBIENTE inventarioAmbienteExistente;

            inventarioAmbienteExistente = entities.INVENTARIO_AMBIENTE.Where(invAtv => invAtv.CodInventarioAmbiente ==
                                                                             inventarioAmbienteModelo.CodInventarioAmbiente).FirstOrDefault();

            if (inventarioAmbienteExistente == null)
            {
                throw new KeyNotFoundException();
            }

            if (inventarioAmbienteModelo.Ativo)
            {
                inventarioAmbienteExistente.Descricao       = inventarioAmbienteModelo.Descricao;
                inventarioAmbienteExistente.ObservacaoGeral = inventarioAmbienteModelo.ObservacaoGeral;

                entities.SaveChanges();
            }

            else
            {
                try
                {
                    DesativarInventario(inventarioAmbienteExistente.CodInventarioAmbiente, entities);

                    inventarioAmbienteExistente = Inserir(inventarioAmbienteModelo, entities);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }

            return(inventarioAmbienteExistente);
        }
示例#5
0
        private INVENTARIO_AMBIENTE InserirInventarioAmbienteComLocalInstalacao(InventarioAmbienteModelo inventarioAmbienteModelo, DB_LaborSafetyEntities entities)
        {
            List <NrInventarioAmbienteModelo>    nrs    = inventarioAmbienteModelo.NR_INVENTARIO_AMBIENTE;
            List <RiscoInventarioAmbienteModelo> riscos = inventarioAmbienteModelo.RISCO_INVENTARIO_AMBIENTE;

            try
            {
                if (inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO == null)
                {
                    throw new Exception("Local de instalação não informado!");
                }

                INVENTARIO_AMBIENTE inventario = new INVENTARIO_AMBIENTE();

                if (string.IsNullOrEmpty(inventarioAmbienteModelo.Codigo))
                {
                    inventario = new INVENTARIO_AMBIENTE()
                    {
                        Codigo          = "IMPORTACAO",
                        CodAmbiente     = inventarioAmbienteModelo.CodAmbiente,
                        Descricao       = inventarioAmbienteModelo.Descricao,
                        ObservacaoGeral = inventarioAmbienteModelo.ObservacaoGeral,
                        RiscoGeral      = inventarioAmbienteModelo.RiscoGeral,
                        DataAtualizacao = DateTime.Now,
                        Ativo           = true
                    };
                }
                else
                {
                    inventario = new INVENTARIO_AMBIENTE()
                    {
                        Codigo          = inventarioAmbienteModelo.Codigo,
                        CodAmbiente     = inventarioAmbienteModelo.CodAmbiente,
                        Descricao       = inventarioAmbienteModelo.Descricao,
                        ObservacaoGeral = inventarioAmbienteModelo.ObservacaoGeral,
                        RiscoGeral      = inventarioAmbienteModelo.RiscoGeral,
                        DataAtualizacao = DateTime.Now,
                        Ativo           = true
                    };
                }
                entities.INVENTARIO_AMBIENTE.Add(inventario);
                entities.SaveChanges();

                long idInv = inventario.CodInventarioAmbiente;

                inventario.Codigo = $"INV_AMB - {idInv}";
                entities.SaveChanges();

                if (nrs != null)
                {
                    foreach (var nr in nrs)
                    {
                        entities.NR_INVENTARIO_AMBIENTE.Add(new NR_INVENTARIO_AMBIENTE()
                        {
                            CodInventarioAmbiente = idInv,
                            CodNR = nr.CodNR,
                            Ativo = true
                        });
                    }

                    entities.SaveChanges();
                }

                if (riscos != null)
                {
                    foreach (var risco in riscos)
                    {
                        var novoRisco = new RISCO_INVENTARIO_AMBIENTE()
                        {
                            CodInventarioAmbiente   = idInv,
                            CodRiscoAmbiente        = risco.CodRiscoAmbiente,
                            CodSeveridade           = risco.CodSeveridade,
                            CodProbabilidade        = risco.CodProbabilidade,
                            FonteGeradora           = risco.FonteGeradora,
                            ProcedimentosAplicaveis = risco.ProcedimentosAplicaveis,
                            ContraMedidas           = risco.ContraMedidas,
                            Ativo = true
                        };
                        entities.RISCO_INVENTARIO_AMBIENTE.Add(novoRisco);
                        entities.SaveChanges();

                        if (risco.EPIRiscoInventarioAmbienteModelo.Count >= 0)
                        {
                            foreach (var epi in risco.EPIRiscoInventarioAmbienteModelo)
                            {
                                entities.EPI_RISCO_INVENTARIO_AMBIENTE.Add(new EPI_RISCO_INVENTARIO_AMBIENTE()
                                {
                                    CodRiscoInventarioAmbiente = novoRisco.CodRiscoInventarioAmbiente,
                                    CodEPI = epi.CodEPI
                                });
                            }
                        }
                        entities.SaveChanges();
                    }
                }

                entities.Configuration.AutoDetectChangesEnabled = true;

                if (inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO.Count == 0)
                {
                    throw new Exception("Existem inventários sem local de instalação a serem inseridos.");
                }

                foreach (var item in inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO)
                {
                    var localEnviado = entities.LOCAL_INSTALACAO.Where(x => x.CodLocalInstalacao == item.CodLocalInstalacao).FirstOrDefault();
                    localEnviado.CodInventarioAmbiente = idInv;
                }
                entities.SaveChanges();
                entities.Configuration.AutoDetectChangesEnabled = false;

                return(inventario);
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
        public Retorno EditarRascunhoInventarioAmbiente(RascunhoInventarioAmbienteModelo rascunhoInventarioAmbienteModelo)
        {
            Retorno retornoInsercao = new Retorno();

            retornoInsercao.localModelo = new List <string>();

            validadorRascunhoInventarioAmbiente.ValidaEdicao(rascunhoInventarioAmbienteModelo);

            List <LocalInstalacaoModelo> locaisInstalacaoOrigem = new List <LocalInstalacaoModelo>();

            locaisInstalacaoOrigem.AddRange(rascunhoInventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO);

            List <LocalInstalacaoModelo> locaisInstalacaoAAssociar = new List <LocalInstalacaoModelo>();

            long codInventarioAmbiente = (long)rascunhoInventarioAmbienteModelo.CodRascunhoInventarioAmbiente;

            using (var entities = new DB_APRPTEntities())
            {
                using (var transaction = entities.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
                {
                    try
                    {
                        if (!rascunhoInventarioAmbienteModelo.novoInventario)
                        {
                            List <string> locaisAInserir = new List <string>();
                            foreach (var itemLi in rascunhoInventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO)
                            {
                                locaisAInserir.Add(itemLi.CodLocalInstalacao.ToString());
                            }
                            rascunhoInventarioAmbienteModelo.CodLocalInstalacao = string.Join(",", locaisAInserir);
                        }

                        rascunhoInventarioAmbientePersistencia.EditarRascunhoInventarioAmbiente(rascunhoInventarioAmbienteModelo, entities, transaction);

                        if (rascunhoInventarioAmbienteModelo.novoInventario)
                        {
                            InventarioAmbienteModelo inventarioAmbienteModelo = new InventarioAmbienteModelo();

                            inventarioAmbienteModelo.CodInventarioAmbiente = (long)rascunhoInventarioAmbienteModelo.CodRascunhoInventarioAmbiente;
                            inventarioAmbienteModelo.Codigo          = rascunhoInventarioAmbienteModelo.Codigo;
                            inventarioAmbienteModelo.CodAmbiente     = (long)rascunhoInventarioAmbienteModelo.CodAmbiente;
                            inventarioAmbienteModelo.Descricao       = rascunhoInventarioAmbienteModelo.Descricao;
                            inventarioAmbienteModelo.ObservacaoGeral = rascunhoInventarioAmbienteModelo.ObservacaoGeral;
                            inventarioAmbienteModelo.RiscoGeral      = (int)rascunhoInventarioAmbienteModelo.RiscoGeral;
                            inventarioAmbienteModelo.DataAtualizacao = DateTime.Now;
                            inventarioAmbienteModelo.Ativo           = true;

                            List <RiscoInventarioAmbienteModelo> listaRisco = new List <RiscoInventarioAmbienteModelo>();
                            foreach (var itemRiscoRascunho in rascunhoInventarioAmbienteModelo.RISCO_RASCUNHO_INVENTARIO_AMBIENTE)
                            {
                                RiscoInventarioAmbienteModelo risco = new RiscoInventarioAmbienteModelo();

                                risco.Ativo = true;
                                risco.CodInventarioAmbiente      = itemRiscoRascunho.CodRascunhoInventarioAmbiente;
                                risco.CodRiscoInventarioAmbiente = itemRiscoRascunho.CodRascunhoRiscoInventarioAmbiente;
                                risco.CodRiscoAmbiente           = itemRiscoRascunho.CodRiscoAmbiente;
                                risco.CodSeveridade           = itemRiscoRascunho.CodSeveridade;
                                risco.CodProbabilidade        = itemRiscoRascunho.CodProbabilidade;
                                risco.FonteGeradora           = itemRiscoRascunho.FonteGeradora;
                                risco.ProcedimentosAplicaveis = itemRiscoRascunho.ProcedimentosAplicaveis;
                                risco.ContraMedidas           = itemRiscoRascunho.ContraMedidas;

                                risco.EPIRiscoInventarioAmbienteModelo = new List <EPIRiscoInventarioAmbienteModelo>();

                                var listaEPI = itemRiscoRascunho.EPIRiscoRascunhoInventarioAmbiente
                                               .Where(a => a.CodRiscoRascunhoInventarioAmbiente == itemRiscoRascunho.CodRiscoAmbiente).ToList();

                                foreach (var itemListaEpi in listaEPI)
                                {
                                    EPIRiscoInventarioAmbienteModelo epi = new EPIRiscoInventarioAmbienteModelo();

                                    epi.CodEPI = itemListaEpi.CodEPI;
                                    epi.CodEpiRiscoInventarioAmbiente = itemListaEpi.CodEpiRiscoRascunhoInventarioAmbiente;
                                    epi.CodRiscoInventarioAmbiente    = itemListaEpi.CodRiscoRascunhoInventarioAmbiente;
                                    risco.EPIRiscoInventarioAmbienteModelo.Add(epi);
                                }

                                listaRisco.Add(risco);
                            }
                            inventarioAmbienteModelo.RISCO_INVENTARIO_AMBIENTE = listaRisco;


                            List <NrInventarioAmbienteModelo> listaNR = new List <NrInventarioAmbienteModelo>();
                            foreach (var itemNrRascunho in rascunhoInventarioAmbienteModelo.NR_RASCUNHO_INVENTARIO_AMBIENTE)
                            {
                                NrInventarioAmbienteModelo nr = new NrInventarioAmbienteModelo();

                                nr.CodNRInventarioAmbiente = itemNrRascunho.CodNrRascunhoInventarioAmbiente;
                                nr.CodNR = itemNrRascunho.CodNR;
                                nr.CodInventarioAmbiente = itemNrRascunho.CodRascunhoInventarioAmbiente;
                                nr.Ativo = true;

                                listaNR.Add(nr);
                            }
                            inventarioAmbienteModelo.NR_INVENTARIO_AMBIENTE = listaNR;

                            //Limpa os locais que vieram
                            rascunhoInventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO.Clear();

                            //List<LOCAL_INSTALACAO> locais = localInstalacaoPersistencia.ListarTodosLIs(entities);

                            foreach (var local in locaisInstalacaoOrigem)
                            {
                                var codLocal = local.CodLocalInstalacao;

                                var localEnviado = localInstalacaoPersistencia.ListarLocalInstalacaoPorId(codLocal, entities);

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

                                //Busca todos os filhos que possuam o codInventarioAmbiente
                                //List<LOCAL_INSTALACAO> locaisFilhos = rascunhoInventarioAmbientePersistencia.BuscaFilhosPorNivelDoInventario
                                //    (local.CodLocalInstalacao, codInventarioAmbiente, entities);

                                foreach (var localAAssociar in locaisEFilhos)
                                {
                                    LocalInstalacaoModelo localModelo = new LocalInstalacaoModelo();
                                    localModelo.CodInventarioAmbiente = localAAssociar.CodInventarioAmbiente;
                                    localModelo.CodLocalInstalacao    = localAAssociar.CodLocalInstalacao;
                                    localModelo.CodPerfilCatalogo     = localAAssociar.CodPerfilCatalogo;
                                    localModelo.CodPeso   = localAAssociar.CodPeso;
                                    localModelo.Descricao = localAAssociar.Descricao;
                                    localModelo.N1        = localAAssociar.N1;
                                    localModelo.N2        = localAAssociar.N2;
                                    localModelo.N3        = localAAssociar.N3;
                                    localModelo.N4        = localAAssociar.N4;
                                    localModelo.N5        = localAAssociar.N5;
                                    localModelo.N6        = localAAssociar.N6;
                                    localModelo.Nome      = localAAssociar.Nome;

                                    locaisInstalacaoAAssociar.Add(localModelo);
                                }
                            }
                            inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO = new List <LocalInstalacaoModelo>();
                            inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO.AddRange(locaisInstalacaoAAssociar);

                            foreach (var item in inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO)
                            {
                                var li = localInstalacaoPersistencia.ListarLocalInstalacaoPorId(item.CodLocalInstalacao);

                                if (li.CodInventarioAmbiente != (long)Constantes.InventarioAmbiente.SEM_INVENTARIO)
                                {
                                    retornoInsercao.status = false;

                                    retornoInsercao.localModelo.Add(li.Nome);

                                    throw new Exception($"O local de instalação {li.Nome} já possui um inventário de ambiente associado.");
                                }
                            }

                            var resultadoInsercao = inventariosAmbiente.Inserir(inventarioAmbienteModelo, entities);
                            inventarioAmbienteModelo.EightIDUsuarioModificador = rascunhoInventarioAmbienteModelo.EightIDUsuarioModificador;
                            logInventarioAmbientePersistencia.Inserir(inventarioAmbienteModelo, resultadoInsercao.CodInventarioAmbiente, entities);
                        }

                        entities.SaveChanges();
                        transaction.Commit();
                        retornoInsercao.status = true;
                        return(retornoInsercao);
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        throw ex;
                    }
                }
            }
        }
        public INVENTARIO_AMBIENTE InserirPorEdicao(InventarioAmbienteModelo inventarioAmbienteModelo, DB_LaborSafetyEntities entities)
        {
            List <NrInventarioAmbienteModelo>    nrs    = inventarioAmbienteModelo.NR_INVENTARIO_AMBIENTE;
            List <RiscoInventarioAmbienteModelo> riscos = inventarioAmbienteModelo.RISCO_INVENTARIO_AMBIENTE;

            try
            {
                if (entities == null)
                {
                    entities = new DB_LaborSafetyEntities();
                }

                entities.Configuration.AutoDetectChangesEnabled = false;

                DesativarInventarioPorCodigo(inventarioAmbienteModelo.Codigo, entities);

                var inventario = new INVENTARIO_AMBIENTE()
                {
                    Codigo          = inventarioAmbienteModelo.Codigo,
                    CodAmbiente     = inventarioAmbienteModelo.CodAmbiente,
                    Descricao       = inventarioAmbienteModelo.Descricao,
                    ObservacaoGeral = inventarioAmbienteModelo.ObservacaoGeral,
                    RiscoGeral      = inventarioAmbienteModelo.RiscoGeral,
                    DataAtualizacao = DateTime.Now,
                    Ativo           = true
                };

                entities.INVENTARIO_AMBIENTE.Add(inventario);
                entities.SaveChanges();

                long idInv = inventario.CodInventarioAmbiente;

                if (nrs != null)
                {
                    foreach (var nr in nrs)
                    {
                        entities.NR_INVENTARIO_AMBIENTE.Add(new NR_INVENTARIO_AMBIENTE()
                        {
                            CodInventarioAmbiente = idInv,
                            CodNR = nr.CodNR,
                            Ativo = true
                        });
                    }

                    entities.SaveChanges();
                }

                if (riscos != null)
                {
                    foreach (var risco in riscos)
                    {
                        var novoRisco = new RISCO_INVENTARIO_AMBIENTE()
                        {
                            CodInventarioAmbiente   = idInv,
                            CodRiscoAmbiente        = risco.CodRiscoAmbiente,
                            CodSeveridade           = risco.CodSeveridade,
                            CodProbabilidade        = risco.CodProbabilidade,
                            FonteGeradora           = risco.FonteGeradora,
                            ProcedimentosAplicaveis = risco.ProcedimentosAplicaveis,
                            ContraMedidas           = risco.ContraMedidas,
                            Ativo = true
                        };
                        entities.RISCO_INVENTARIO_AMBIENTE.Add(novoRisco);
                        entities.SaveChanges();

                        if (risco.EPIRiscoInventarioAmbienteModelo.Count >= 0)
                        {
                            foreach (var epi in risco.EPIRiscoInventarioAmbienteModelo)
                            {
                                entities.EPI_RISCO_INVENTARIO_AMBIENTE.Add(new EPI_RISCO_INVENTARIO_AMBIENTE()
                                {
                                    CodRiscoInventarioAmbiente = novoRisco.CodRiscoInventarioAmbiente,
                                    CodEPI = epi.CodEPI
                                });
                            }
                        }
                        entities.SaveChanges();
                    }
                }

                if (inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO != null)
                {
                    foreach (var li in inventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO)
                    {
                        var localEnviado = entities.LOCAL_INSTALACAO.Where(x => x.CodLocalInstalacao == li.CodLocalInstalacao).FirstOrDefault();
                        localEnviado.CodInventarioAmbiente = idInv;
                    }
                    entities.ChangeTracker.DetectChanges();
                    entities.SaveChanges();
                }

                return(inventario);
            }

            catch (Exception exception)
            {
                throw exception;
            }
            finally
            {
                entities.Configuration.AutoDetectChangesEnabled = true;
            }
        }
示例#8
0
        public LOG_INVENTARIO_AMBIENTE Editar(List <LOCAL_INSTALACAO> novosLIs, InventarioAmbienteModelo novoInventario,
                                              DB_LaborSafetyEntities entities = null)
        {
            if (entities == null)
            {
                entities = new DB_LaborSafetyEntities();
            }

            //Busca os dados do inventario antigo (anterior à edição)
            var inventarioAmbienteExistente = entities.INVENTARIO_AMBIENTE
                                              .Include(x => x.NR_INVENTARIO_AMBIENTE)
                                              .Include(x => x.RISCO_INVENTARIO_AMBIENTE)
                                              .Include(x => x.LOCAL_INSTALACAO)
                                              .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))
                                              .Where(invAmb => invAmb.CodInventarioAmbiente == novoInventario.CodInventarioAmbiente && invAmb.Ativo).FirstOrDefault();

            if (inventarioAmbienteExistente == null)
            {
                throw new Exception("Inventário não encontrado na base de dados");
            }

            //Verifica se já existe LOG
            var logExistente = entities.LOG_INVENTARIO_AMBIENTE.Where(x => x.CodInventario == novoInventario.CodInventarioAmbiente).FirstOrDefault();

            #region Insere os dados do log de inventário

            LOG_INVENTARIO_AMBIENTE logInventario = new LOG_INVENTARIO_AMBIENTE();

            logInventario.CodAmbienteAntigo = inventarioAmbienteExistente.CodAmbiente;
            logInventario.CodAmbienteNovo   = novoInventario.CodAmbiente;

            logInventario.CodLogTipoOperacao = (long)Constantes.TipoOperacaoLog.EDICAO;

            //Armazena os LI's antigos
            string codigoLIsAntigos = string.Empty;
            foreach (var li in inventarioAmbienteExistente.LOCAL_INSTALACAO)
            {
                codigoLIsAntigos += codigoLIsAntigos.Length == 0 ? li.CodLocalInstalacao.ToString() : "," + li.CodLocalInstalacao;
            }

            logInventario.CodigosLIsAntigos = codigoLIsAntigos;

            //Armazena os LI's novos
            string codigoLIsNovos = string.Empty;
            foreach (var li in novoInventario.LOCAL_INSTALACAO_MODELO)
            {
                codigoLIsNovos += codigoLIsNovos.Length == 0 ? li.CodLocalInstalacao.ToString() : "," + li.CodLocalInstalacao;
            }

            logInventario.CodigosLIsNovos = codigoLIsNovos;

            //Armazena as NR's antigas
            string codigoNRsAntigas = string.Empty;
            foreach (var nr in inventarioAmbienteExistente.NR_INVENTARIO_AMBIENTE)
            {
                codigoNRsAntigas += codigoNRsAntigas.Length == 0 ? nr.CodNR.ToString() : "," + nr.CodNR;
            }

            logInventario.CodigosNRsAntigas = codigoNRsAntigas;

            //Armazena as NR's novas
            string codigoNRsNovas = string.Empty;
            foreach (var nr in novoInventario.NR_INVENTARIO_AMBIENTE)
            {
                codigoNRsNovas += codigoNRsNovas.Length == 0 ? nr.CodNR.ToString() : "," + nr.CodNR;
            }

            logInventario.CodigosNRsNovas = codigoNRsNovas;

            var ultimoLog = entities.LOG_INVENTARIO_AMBIENTE.Where(x => x.CodInventario == novoInventario.CodInventarioAmbiente)
                            .OrderByDescending(u => u.CodInventariosAntigos).FirstOrDefault();

            if (ultimoLog == null)
            {
                logInventario.CodInventariosAntigos = $"{inventarioAmbienteExistente.CodInventarioAmbiente}";
            }

            else
            {
                if (string.IsNullOrEmpty(ultimoLog.CodInventariosAntigos))
                {
                    logInventario.CodInventariosAntigos = $"{inventarioAmbienteExistente.CodInventarioAmbiente}";
                }

                else
                {
                    logInventario.CodInventariosAntigos = $"{ultimoLog.CodInventariosAntigos},{inventarioAmbienteExistente.CodInventarioAmbiente}";
                }
            }

            logInventario.CodInventario         = novoInventario.CodInventarioAmbiente;
            logInventario.CodUsuarioModificador = novoInventario.EightIDUsuarioModificador;
            logInventario.DescricaoAntiga       = inventarioAmbienteExistente.Descricao;
            logInventario.DescricaoNova         = novoInventario.Descricao;
            logInventario.ObsGeralAntiga        = inventarioAmbienteExistente.ObservacaoGeral;
            logInventario.ObsGeralNova          = novoInventario.ObservacaoGeral;
            logInventario.RiscoGeralAntigo      = inventarioAmbienteExistente.RiscoGeral;
            logInventario.RiscoGeralNovo        = novoInventario.RiscoGeral;
            logInventario.DataAlteracao         = DateTime.Now;

            entities.LOG_INVENTARIO_AMBIENTE.Add(logInventario);
            entities.SaveChanges();

            #endregion

            #region Insere os dados do log de risco do inventário

            //Armazena os riscos
            List <LOG_RISCO_INVENTARIO_AMBIENTE> logRiscos = new List <LOG_RISCO_INVENTARIO_AMBIENTE>();

            foreach (var risco in inventarioAmbienteExistente.RISCO_INVENTARIO_AMBIENTE)
            {
                LOG_RISCO_INVENTARIO_AMBIENTE logRisco = new LOG_RISCO_INVENTARIO_AMBIENTE();
                string codigosEPIs = string.Empty;

                //Busca todos os EPI's
                if (risco.EPI_RISCO_INVENTARIO_AMBIENTE.Count > 0)
                {
                    foreach (var epi in risco.EPI_RISCO_INVENTARIO_AMBIENTE)
                    {
                        codigosEPIs += codigosEPIs.Length == 0 ? epi.CodEPI.ToString() : "," + epi.CodEPI;
                    }

                    logRisco.CodigosEPIs = codigosEPIs;
                }
                logRisco.CodProbabilidade        = risco.CodProbabilidade;
                logRisco.ProcedimentosAplicaveis = risco.ProcedimentosAplicaveis;
                logRisco.ContraMedidas           = risco.ContraMedidas;
                logRisco.FonteGeradora           = risco.FonteGeradora;
                logRisco.CodRisco      = risco.CodRiscoAmbiente;
                logRisco.CodSeveridade = risco.CodSeveridade;

                logRisco.CodLogInventarioAmbiente = logInventario.CodLogInventarioAmbiente;

                entities.LOG_RISCO_INVENTARIO_AMBIENTE.Add(logRisco);
                entities.SaveChanges();

                logRiscos.Add(logRisco);
            }

            logInventario.LOG_RISCO_INVENTARIO_AMBIENTE = logRiscos;
            entities.SaveChanges();

            #endregion

            return(logInventario);
        }