Example #1
0
        public ActionResult CadastrarControleDeRisco(ReconhecimentoDoRisco entidade, ControleDeRiscos oControle, string UKControle, string UKWorkarea, string UKRisco)
        {
            try
            {
                Guid UK_Workarea = Guid.Parse(UKWorkarea);
                Guid UK_Risco    = Guid.Parse(UKRisco);



                if (string.IsNullOrEmpty(UKControle))
                {
                    throw new Exception("Não foi possível localizar o Controle.");
                }

                if (string.IsNullOrEmpty(UKRisco))
                {
                    throw new Exception("Não foi possivel localizar o risco.");
                }

                if (string.IsNullOrEmpty(UKWorkarea))
                {
                    throw new Exception("Não foi possivel localizar a workArea.");
                }

                ReconhecimentoDoRisco oReconhecimento = ReconhecimentoBusiness.Consulta.FirstOrDefault(p => string.IsNullOrEmpty(p.UsuarioExclusao) && p.UKRisco.Equals(UK_Risco) && p.UKWorkarea.Equals(UK_Workarea));


                ReconhecimentoDoRisco pReconhecimento = new ReconhecimentoDoRisco()
                {
                    UKWorkarea = UK_Workarea,
                    UKRisco    = UK_Risco,
                    //FonteGeradora = entidade.FonteGeradora,
                    Tragetoria      = entidade.Tragetoria,
                    EClasseDoRisco  = entidade.EClasseDoRisco,
                    UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
                };

                ReconhecimentoBusiness.Inserir(pReconhecimento);

                ReconhecimentoDoRisco pRec = ReconhecimentoBusiness.Consulta.FirstOrDefault(p => string.IsNullOrEmpty(p.UsuarioExclusao) && p.UKRisco.Equals(UK_Risco));

                List <Guid> filtro = new List <Guid>();

                if (UKControle.Contains(","))
                {
                    foreach (string ativ in UKControle.Split(','))
                    {
                        if (!string.IsNullOrEmpty(ativ.Trim()))
                        {
                            var pesControRisco = from A in ReconhecimentoBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
                                                 join B in ControleDeRiscosBusiness.Consulta.Where(p => string.IsNullOrEmpty(p.UsuarioExclusao)).ToList()
                                                 on A.UniqueKey equals B.UKReconhecimentoDoRisco
                                                 select new
                            {
                                UniqueReconhecimento = A.UniqueKey,
                                UKWorkarea           = A.UKWorkarea,
                                Risco = A.UKRisco,
                                //FonteGer = A.FonteGeradora,
                                UniqueControle = B.UKReconhecimentoDoRisco,
                                //Controle = B.Controle
                            };


                            if (pesControRisco != null)
                            {
                                foreach (var item in pesControRisco)
                                {
                                    //if (item.Controle.Equals(ativ.Trim()) && item.FonteGer.Equals(pRec.FonteGeradora))
                                    //{
                                    //    filtro.Add(item.UniqueReconhecimento);
                                    //}
                                }
                            }


                            //ControleDeRiscos pTemp = ControleDeRiscosBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.EControle.Equals(ativ.Trim()) && a.UKFonteGeradora.Equals(pRec.FonteGeradora));

                            if (filtro.Count == 0)
                            {
                                ControleDeRiscosBusiness.Inserir(new ControleDeRiscos()
                                {
                                    UKReconhecimentoDoRisco = pReconhecimento.UniqueKey,
                                    UKClassificacaoDaMedia  = oControle.UKClassificacaoDaMedia,
                                    //Controle = ativ.Trim(),
                                    EControle = oControle.EControle,
                                    //Descricao = oControle.Descricao,
                                    UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
                                });
                            }
                            else
                            {
                                ReconhecimentoDoRisco qReconhecimento = ReconhecimentoBusiness.Consulta.FirstOrDefault(p => string.IsNullOrEmpty(p.UsuarioExclusao) && p.UKRisco.Equals(UK_Risco) && p.UKWorkarea.Equals(UK_Workarea));


                                qReconhecimento.UsuarioExclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login;
                                ReconhecimentoBusiness.Terminar(qReconhecimento);

                                throw new Exception("Este controle já existe para este Risco e para esta fonte Geradora.");

                                // return Json(new { resultado = new RetornoJSON() { Erro = "Este controle já existe para este Risco e para esta fonte Geradora." } });
                            }
                        }
                    }
                }
                else
                {
                    //ControleDeRiscos pTemp = ControleDeRiscosBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.EControle.Equals(UKControle.Trim()) && a.UKFonteGeradora.Equals(pRec.FonteGeradora));



                    if (filtro.Count == 0)
                    {
                        ControleDeRiscosBusiness.Inserir(new ControleDeRiscos()
                        {
                            UKReconhecimentoDoRisco = pReconhecimento.UniqueKey,
                            UKClassificacaoDaMedia  = oControle.UKClassificacaoDaMedia,
                            //Controle = UKControle.Trim(),
                            EControle = oControle.EControle,
                            //Descricao = oControle.Descricao,
                            UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
                        });

                        ReconhecimentoBusiness.Inserir(pReconhecimento);
                    }
                    else
                    {
                        pReconhecimento.UsuarioExclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login;
                        ReconhecimentoBusiness.Terminar(pReconhecimento);

                        throw new Exception("Este controle já existe para este Risco e para esta fonte Geradora.");

                        // return Json(new { resultado = new RetornoJSON() { Erro = "Este controle já existe para este Risco e para esta fonte Geradora." } });
                    }
                }


                return(Json(new { resultado = new RetornoJSON()
                                  {
                                      Sucesso = "Controles dos riscos vinculados com sucesso."
                                  } }));
            }
            catch (Exception ex)
            {
                return(Json(new { resultado = new RetornoJSON()
                                  {
                                      Erro = ex.Message
                                  } }));
            }
        }
Example #2
0
        public ActionResult CadastrarControleDeRisco(VMNovoReconhecimentoControle entidade)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    List <TipoDeControle> tiposDeControle = new List <TipoDeControle>();

                    if (entidade?.Controles?.Count == 0)
                    {
                        throw new Exception("Nenhum tipo de controle foi identificado.");
                    }

                    foreach (string[] item in entidade.Controles)
                    {
                        Guid UKTipo = Guid.Parse(item[0]);

                        TipoDeControle tipoControl = TipoDeControleBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.UniqueKey.Equals(UKTipo));

                        if (tipoControl == null)
                        {
                            throw new Exception("Não foi possível encontrar um do(s) tipo(s) de controle na base de dados.");
                        }

                        tiposDeControle.Add(tipoControl);
                    }



                    ReconhecimentoDoRisco oReconhecimento = ReconhecimentoBusiness.Consulta.FirstOrDefault(p => string.IsNullOrEmpty(p.UsuarioExclusao) &&

                                                                                                           p.UKAtividade.Equals(entidade.UKAtividade) &&
                                                                                                           p.UKPerigo.Equals(entidade.UKPerigo) &&
                                                                                                           p.UKRisco.Equals(entidade.UKRisco)
                                                                                                           );

                    if (oReconhecimento == null)
                    {
                        oReconhecimento = new ReconhecimentoDoRisco()
                        {
                            UKAtividade     = entidade.UKAtividade,
                            UKPerigo        = entidade.UKPerigo,
                            UKRisco         = entidade.UKRisco,
                            Tragetoria      = entidade.Tragetoria,
                            EClasseDoRisco  = entidade.EClasseDoRisco,
                            UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
                        };

                        ReconhecimentoBusiness.Inserir(oReconhecimento);
                    }



                    foreach (string[] item in entidade.Controles)
                    {
                        Guid UKTipo = Guid.Parse(item[0]);
                        Guid UKClassificacaoMedida = Guid.Parse(item[1]);

                        ControleDeRiscos obj = new ControleDeRiscos()
                        {
                            UsuarioInclusao         = CustomAuthorizationProvider.UsuarioAutenticado.Login,
                            UKReconhecimentoDoRisco = oReconhecimento.UniqueKey,
                            UKTipoDeControle        = UKTipo,
                            UKClassificacaoDaMedia  = UKClassificacaoMedida,
                            EControle = (EControle)Enum.Parse(typeof(EControle), item[2], true)
                        };

                        if (item[3] != null && !string.IsNullOrEmpty(item[3]))
                        {
                            obj.UKLink = Guid.Parse(item[3]);
                        }

                        ControleDeRiscosBusiness.Inserir(obj);
                    }


                    return(Json(new { resultado = new RetornoJSON()
                                      {
                                          Sucesso = "Reconhecimento e controles dos riscos cadastrados com sucesso."
                                      } }));
                }
                else
                {
                    return(Json(new { resultado = TratarRetornoValidacaoToJSON() }));
                }
            }
            catch (Exception ex)
            {
                return(Json(new { resultado = new RetornoJSON()
                                  {
                                      Erro = ex.Message
                                  } }));
            }
        }