public AMBIENTE Inserir(AmbienteModelo ambienteModelo)
        {
            try
            {
                using (var entities = new DB_LaborSafetyEntities())
                {
                    var ambiente = new AMBIENTE()
                    {
                        Nome      = ambienteModelo.Nome,
                        Descricao = ambienteModelo.Descricao,
                        Ativo     = true
                    };

                    entities.AMBIENTE.Add(ambiente);
                    entities.SaveChanges();

                    return(ambiente);
                }
            }

            catch (Exception exception)
            {
                throw exception;
            }
        }
        public void Inserir(AtividadePadraoModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                var atividadePadrao = new ATIVIDADE_PADRAO()
                {
                    Nome      = modelo.Nome,
                    Descricao = modelo.Descricao,
                    Ativo     = true
                };

                entities.ATIVIDADE_PADRAO.Add(atividadePadrao);
                entities.SaveChanges();
            }
        }
        public void Inserir(DisciplinaModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                var disciplina = new DISCIPLINA()
                {
                    Nome      = modelo.Nome,
                    Descricao = modelo.Descricao,
                    Ativo     = true
                };

                entities.DISCIPLINA.Add(disciplina);
                entities.SaveChanges();
            }
        }
        public void ExcluirRascunhoInventarioAmbiente(long id, DB_LaborSafetyEntities entities)
        {
            if (entities == null)
            {
                using (entities = new DB_LaborSafetyEntities())
                {
                    entities.NR_RASCUNHO_INVENTARIO_AMBIENTE.RemoveRange(
                        entities.NR_RASCUNHO_INVENTARIO_AMBIENTE
                        .Where(nr => nr.CodRascunhoInventarioAmbiente == id).ToList());

                    entities.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.RemoveRange(
                        entities.RISCO_RASCUNHO_INVENTARIO_AMBIENTE
                        .Where(risco => risco.CodRascunhoInventarioAmbiente == id).ToList());

                    entities.EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE.RemoveRange(
                        entities.EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE
                        .Where(risc => risc.CodRiscoRascunhoInventarioAmbiente == risc.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.CodRiscoRascunhoInventarioAmbiente && risc.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.CodRascunhoInventarioAmbiente == id).ToList());

                    var delInv = entities.RASCUNHO_INVENTARIO_AMBIENTE.Where(invAmb => invAmb.CodRascunhoInventarioAmbiente == id).FirstOrDefault();

                    entities.RASCUNHO_INVENTARIO_AMBIENTE.Remove(delInv);

                    entities.SaveChanges();
                }
            }

            else
            {
                entities.NR_RASCUNHO_INVENTARIO_AMBIENTE.RemoveRange(
                    entities.NR_RASCUNHO_INVENTARIO_AMBIENTE
                    .Where(nr => nr.CodRascunhoInventarioAmbiente == id).ToList());

                entities.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.RemoveRange(
                    entities.RISCO_RASCUNHO_INVENTARIO_AMBIENTE
                    .Where(risco => risco.CodRascunhoInventarioAmbiente == id).ToList());

                entities.EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE.RemoveRange(
                    entities.EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE
                    .Where(risc => risc.CodRiscoRascunhoInventarioAmbiente == risc.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.CodRiscoRascunhoInventarioAmbiente && risc.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.CodRascunhoInventarioAmbiente == id).ToList());


                var delInv = entities.RASCUNHO_INVENTARIO_AMBIENTE.Where(invAmb => invAmb.CodRascunhoInventarioAmbiente == id).FirstOrDefault();

                entities.RASCUNHO_INVENTARIO_AMBIENTE.Remove(delInv);

                entities.SaveChanges();
            }
        }
        public void DesativarAmbiente(long codAmbienteExistente)
        {
            using (DB_LaborSafetyEntities entities = new DB_LaborSafetyEntities())
            {
                AMBIENTE ambienteExistente = entities.AMBIENTE.Where(amb => amb.CodAmbiente == codAmbienteExistente).FirstOrDefault();

                if (ambienteExistente == null)
                {
                    throw new Exception("O ambiente informado não foi encontrado na base de dados.");
                }

                ambienteExistente.Ativo = false;

                entities.SaveChanges();
            }
        }
        public void Excluir(long codPessoa)
        {
            using (DB_LaborSafetyEntities entities = new DB_LaborSafetyEntities())
            {
                var pessoaAExcluir = entities.PESSOA.Where(pessoa => pessoa.CodPessoa == codPessoa).FirstOrDefault();

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

                pessoaAExcluir.Ativo = Convert.ToBoolean(Constantes.Status.INATIVO);

                entities.SaveChanges();
            }
        }
        public void ExcluirDisciplina(DisciplinaModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                //Verifica se a disciplina existe
                var disciplinaExistente = this.ListarDisciplinaPorNome(modelo.Nome);

                if (disciplinaExistente == null)
                {
                    throw new Exception("A disciplina informada não existe!");
                }

                disciplinaExistente.Ativo = false;

                entities.SaveChanges();
            }
        }
Exemple #8
0
        public void AtualizaCodigoInventarioDoLocal(long idLocal, long idInventarioAmbiente, DB_LaborSafetyEntities entities)
        {
            entities = new DB_LaborSafetyEntities();

            //entities.Configuration.AutoDetectChangesEnabled = true;

            LOCAL_INSTALACAO local = entities.LOCAL_INSTALACAO.Where(invAmb => invAmb.CodLocalInstalacao == idLocal).FirstOrDefault();

            if (local == null)
            {
                throw new Exception("Local informado inexistente!");
            }

            local.CodInventarioAmbiente = idInventarioAmbiente;

            entities.SaveChanges();
        }
        public void ExcluirAtividade(AtividadePadraoModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                //Verifica se a disciplina existe
                var atividadeExistente = this.ListarAtividadePorNome(modelo.Nome);

                if (atividadeExistente == null)
                {
                    throw new Exception("A atividade informada não existe!");
                }

                atividadeExistente.Ativo = false;

                entities.SaveChanges();
            }
        }
Exemple #10
0
        public void ExcluirRascunhoInventarioAtividade(long id, DB_LaborSafetyEntities entities)
        {
            if (entities == null)
            {
                using (entities = new DB_LaborSafetyEntities())
                {
                    entities.LOCAL_INSTALACAO_RASCUNHO_INVENTARIO_ATIVIDADE.RemoveRange(
                        entities.LOCAL_INSTALACAO_RASCUNHO_INVENTARIO_ATIVIDADE
                        .Where(local => local.CodRascunhoInventarioAtividade == id).ToList());

                    entities.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.RemoveRange(
                        entities.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE
                        .Where(risc => risc.CodRascunhoInventarioAtividade == id).ToList());

                    entities.EPI_RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.RemoveRange(
                        entities.EPI_RISCO_RASCUNHO_INVENTARIO_ATIVIDADE
                        .Where(risc => risc.CodRiscoRascunhoInventarioAtividade == risc.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.CodRiscoRascunhoInventarioAtividade && risc.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.CodRascunhoInventarioAtividade == id).ToList());

                    var delInventario = entities.RASCUNHO_INVENTARIO_ATIVIDADE.Where(invAtv => invAtv.CodRascunhoInventarioAtividade == id).FirstOrDefault();

                    entities.RASCUNHO_INVENTARIO_ATIVIDADE.Remove(delInventario);

                    entities.SaveChanges();
                }
            }
            else
            {
                entities.LOCAL_INSTALACAO_RASCUNHO_INVENTARIO_ATIVIDADE.RemoveRange(
                    entities.LOCAL_INSTALACAO_RASCUNHO_INVENTARIO_ATIVIDADE
                    .Where(local => local.CodRascunhoInventarioAtividade == id).ToList());

                entities.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.RemoveRange(
                    entities.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE
                    .Where(risc => risc.CodRascunhoInventarioAtividade == id).ToList());

                entities.EPI_RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.RemoveRange(
                    entities.EPI_RISCO_RASCUNHO_INVENTARIO_ATIVIDADE
                    .Where(risc => risc.CodRiscoRascunhoInventarioAtividade == risc.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.CodRiscoRascunhoInventarioAtividade && risc.RISCO_RASCUNHO_INVENTARIO_ATIVIDADE.CodRascunhoInventarioAtividade == id).ToList());

                var delInv = entities.RASCUNHO_INVENTARIO_ATIVIDADE.Where(invAtv => invAtv.CodRascunhoInventarioAtividade == id).FirstOrDefault();

                entities.RASCUNHO_INVENTARIO_ATIVIDADE.Remove(delInv);

                entities.SaveChanges();
            }
        }
        public void Editar(DisciplinaModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                //Verifica se a disciplina existe
                var disciplinaExistente = this.ListarDisciplinaPorNome(modelo.Descricao);

                if (disciplinaExistente == null)
                {
                    throw new Exception("A disciplina informada não existe!");
                }

                disciplinaExistente.Nome      = modelo.Descricao;
                disciplinaExistente.Descricao = modelo.Descricao;

                entities.SaveChanges();
            }
        }
Exemple #12
0
        public void Excluir(PerfilCatalogoModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                //Verifica se perfil existe
                var perfilCatalogoExistente = this.ListarPerfilCatalogoPorCodigo(modelo.Codigo, entities);

                if (perfilCatalogoExistente == null)
                {
                    throw new Exception("O perfil de catálogo informado não existe!");
                }


                perfilCatalogoExistente.Ativo = false;

                entities.SaveChanges();
            }
        }
        public void ExcluirInventarioAmbiente(long id)
        {
            using (DB_LaborSafetyEntities entities = new DB_LaborSafetyEntities())
            {
                entities.NR_INVENTARIO_AMBIENTE.RemoveRange(
                    entities.NR_INVENTARIO_AMBIENTE
                    .Where(nr => nr.CodInventarioAmbiente == id).ToList());

                entities.RISCO_INVENTARIO_AMBIENTE.RemoveRange(
                    entities.RISCO_INVENTARIO_AMBIENTE
                    .Where(risco => risco.CodInventarioAmbiente == id).ToList());

                var delInv = entities.INVENTARIO_AMBIENTE.Where(invAmb => invAmb.CodInventarioAmbiente == id).FirstOrDefault();

                entities.INVENTARIO_AMBIENTE.Remove(delInv);

                entities.SaveChanges();
            }
        }
        public void Editar(AtividadePadraoModelo modelo)
        {
            using (var entities = new DB_LaborSafetyEntities())
            {
                //Verifica se a atividade existe
                var atividadeExistente = this.ListarAtividadePorNome(modelo.Nome);

                if (atividadeExistente == null)
                {
                    throw new Exception("A atividade informada não existe!");
                }

                atividadeExistente.Nome      = modelo.Nome;
                atividadeExistente.Descricao = modelo.Descricao;


                entities.SaveChanges();
            }
        }
        public void Editar(PessoaModelo pessoaModelo)
        {
            using (DB_LaborSafetyEntities entities = new DB_LaborSafetyEntities())
            {
                PESSOA pessoaExistente = entities.PESSOA.Where(p => p.CodPessoa == pessoaModelo.CodPessoa && p.Ativo).FirstOrDefault();

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

                pessoaExistente.CodPessoa = pessoaModelo.CodPessoa;
                pessoaExistente.Matricula = pessoaModelo.Matricula;
                pessoaExistente.Nome      = pessoaModelo.Nome;
                pessoaExistente.CPF       = pessoaModelo.CPF;
                pessoaExistente.Telefone  = pessoaModelo.Telefone;
                pessoaExistente.Email     = pessoaModelo.Email;
                pessoaExistente.Empresa   = pessoaModelo.Empresa;

                entities.SaveChanges();
            }
        }
        public void EditarNrInventarioAmbiente(long idInventario, long idNr)
        {
            using (DB_LaborSafetyEntities entities = new DB_LaborSafetyEntities())
            {
                NR_INVENTARIO_AMBIENTE inventarioAmbienteExistente = entities.NR_INVENTARIO_AMBIENTE.Where(invAmb => invAmb.CodInventarioAmbiente == idInventario).FirstOrDefault();
                NR nrInventarioAmbienteExistente = entities.NR.FirstOrDefault(invAmb => invAmb.CodNR == idNr);

                if (inventarioAmbienteExistente == null)
                {
                    throw new KeyNotFoundException();
                }
                else if (nrInventarioAmbienteExistente == null)
                {
                    throw new KeyNotFoundException();
                }
                else
                {
                    inventarioAmbienteExistente.CodNR = idNr;
                }
                entities.SaveChanges();
            }
        }
        public AMBIENTE Editar(AmbienteModelo ambienteModelo)
        {
            try
            {
                using (var entities = new DB_LaborSafetyEntities())
                {
                    var ambienteExistente = entities.AMBIENTE.Where(x => x.CodAmbiente == ambienteModelo.CodAmbiente).FirstOrDefault();

                    ambienteExistente.Nome      = ambienteModelo.Nome;
                    ambienteExistente.Descricao = ambienteModelo.Descricao;
                    ambienteExistente.Ativo     = true;

                    entities.SaveChanges();

                    return(ambienteExistente);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public void EditarRiscoInventarioAmbiente(long idInventario, long idRisco)
        {
            using (DB_LaborSafetyEntities entities = new DB_LaborSafetyEntities())
            {
                RISCO_INVENTARIO_AMBIENTE inventarioAmbienteExistente = entities.RISCO_INVENTARIO_AMBIENTE.Where(invAmb => invAmb.CodInventarioAmbiente == idInventario).FirstOrDefault();
                RISCO riscoInventarioAmbienteExistente = entities.RISCO.FirstOrDefault(invAmb => invAmb.CodRisco == idRisco);

                if (inventarioAmbienteExistente == null)
                {
                    throw new KeyNotFoundException();
                }
                else if (riscoInventarioAmbienteExistente == null)
                {
                    throw new KeyNotFoundException();
                }
                else
                {
                    inventarioAmbienteExistente.CodRiscoAmbiente = idRisco;
                }

                entities.SaveChanges();
            }
        }
        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);
        }
Exemple #20
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 void Inserir(RascunhoAprModelo rascunhoAprModelo, DB_LaborSafetyEntities entities)
        {
            List <OperacaoAprModelo>   operacaoApr = rascunhoAprModelo.OPERACAO_APR;
            List <AprovadorAprModelo>  aprovadores = rascunhoAprModelo.APROVADOR_APR;
            List <ExecutanteAprModelo> executores  = rascunhoAprModelo.EXECUTANTE_APR;
            List <PessoaModelo>        pessoas     = rascunhoAprModelo.PESSOA;

            try
            {
                var apr = new APR()
                {
                    CodStatusAPR     = rascunhoAprModelo.CodStatusAPR,
                    NumeroSerie      = rascunhoAprModelo.OrdemManutencao,
                    OrdemManutencao  = rascunhoAprModelo.OrdemManutencao,
                    Descricao        = rascunhoAprModelo.Descricao,
                    RiscoGeral       = rascunhoAprModelo.RiscoGeral,
                    DataAprovacao    = DateTime.Now,
                    DataInicio       = DateTime.Now,
                    DataEncerramento = DateTime.Now,
                    Ativo            = true
                };

                entities.APR.Add(apr);
                entities.SaveChanges();

                long id = apr.CodAPR;

                if (operacaoApr != null)
                {
                    foreach (var atividade in operacaoApr)
                    {
                        var codLocalInstalacao = entities.LOCAL_INSTALACAO.Where(lc => lc.Nome == atividade.NomeLI).FirstOrDefault();

                        entities.OPERACAO_APR.Add(new OPERACAO_APR()
                        {
                            CodAPR        = id,
                            CodStatusAPR  = atividade.CodStatusAPR,
                            Codigo        = atividade.Codigo,
                            Descricao     = atividade.Descricao,
                            CodLI         = codLocalInstalacao.CodLocalInstalacao,
                            CodDisciplina = atividade.CodDisciplina,
                            CodAtvPadrao  = atividade.CodAtvPadrao
                        });
                        //InserirRiscoApr(id, codLocalInstalacao.CodLocalInstalacao, entities);
                    }
                }

                foreach (var aprovador in aprovadores)
                {
                    //InsereEditaPessoa(entities, pessoas, true, id, aprovador.CodPessoa);
                }

                foreach (var executor in executores)
                {
                    //InsereEditaPessoa(entities, pessoas, false, id, executor.CodPessoa);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        // insert inventario ambiente
        public RASCUNHO_INVENTARIO_AMBIENTE Inserir(RascunhoInventarioAmbienteModelo rascunhoInventarioAmbienteModelo, DB_LaborSafetyEntities entities)
        {
            List <NrRascunhoInventarioAmbienteModelo>    nrs    = rascunhoInventarioAmbienteModelo.NR_RASCUNHO_INVENTARIO_AMBIENTE;
            List <RiscoRascunhoInventarioAmbienteModelo> riscos = rascunhoInventarioAmbienteModelo.RISCO_RASCUNHO_INVENTARIO_AMBIENTE;
            List <LocalInstalacaoModelo> locais = rascunhoInventarioAmbienteModelo.LOCAL_INSTALACAO_MODELO;

            entities.Configuration.AutoDetectChangesEnabled = false;

            try
            {
                var inventario = new RASCUNHO_INVENTARIO_AMBIENTE()
                {
                    Codigo             = $"R_INV_AMB - {rascunhoInventarioAmbienteModelo.CodRascunhoInventarioAmbiente} - {rascunhoInventarioAmbienteModelo.RiscoGeral}",
                    CodAmbiente        = rascunhoInventarioAmbienteModelo.CodAmbiente,
                    Descricao          = rascunhoInventarioAmbienteModelo.Descricao,
                    ObservacaoGeral    = rascunhoInventarioAmbienteModelo.ObservacaoGeral,
                    RiscoGeral         = rascunhoInventarioAmbienteModelo.RiscoGeral,
                    CodLocalInstalacao = rascunhoInventarioAmbienteModelo.CodLocalInstalacao
                };

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

                long idInv = inventario.CodRascunhoInventarioAmbiente;

                if (nrs != null)
                {
                    foreach (var nr in nrs)
                    {
                        entities.NR_RASCUNHO_INVENTARIO_AMBIENTE.Add(new NR_RASCUNHO_INVENTARIO_AMBIENTE()
                        {
                            CodRascunhoInventarioAmbiente = idInv,
                            CodNR = nr.CodNR
                        });
                    }

                    entities.SaveChanges();
                }

                if (riscos != null)
                {
                    foreach (var risco in riscos)
                    {
                        var novoRisco = new RISCO_RASCUNHO_INVENTARIO_AMBIENTE()
                        {
                            CodRascunhoInventarioAmbiente = idInv,
                            CodRisco                = risco.CodRiscoAmbiente,
                            CodSeveridade           = risco.CodSeveridade,
                            CodProbabilidade        = risco.CodProbabilidade,
                            FonteGeradora           = risco.FonteGeradora,
                            ProcedimentosAplicaveis = risco.ProcedimentosAplicaveis,
                            ContraMedidas           = risco.ContraMedidas
                        };
                        entities.RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Add(novoRisco);
                        entities.SaveChanges();
                        if (risco.EPIRiscoRascunhoInventarioAmbiente.Count >= 0)
                        {
                            foreach (var epi in risco.EPIRiscoRascunhoInventarioAmbiente)
                            {
                                entities.EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE.Add(new EPI_RISCO_RASCUNHO_INVENTARIO_AMBIENTE()
                                {
                                    CodRiscoRascunhoInventarioAmbiente = novoRisco.CodRiscoRascunhoInventarioAmbiente,
                                    CodEPI = epi.CodEPI
                                });
                            }
                        }
                    }

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

                    entities.Configuration.AutoDetectChangesEnabled = true;
                }
                return(inventario);
            }

            catch (Exception exception)
            {
                throw exception;
            }
        }