示例#1
0
        public IActionResult CheckIfDador([FromBody] JsonDTO context)
        {
            string docId = context.DocIdentificacao;

            // 1 - Verificar se o dador existe no sistema
            var dadorAlvo = _encryptor.DecryptDataList(_context.Dador.ToList()).SingleOrDefault(d => d.DocIdentificacao == docId);

            if (dadorAlvo == null)
            {
                return(NotFound());
            }

            // 2 - Get Amostra do tipo Espermograma do Dador
            var amostraAlvo = _context.Amostra.SingleOrDefault(a => a.DadorId == dadorAlvo.DadorId && a.TipoAmostra == TipoAmostraEnum.Espermatozoide);

            if (amostraAlvo == null)
            {
                return(NotFound());
            }

            // 3 - Get Espermograma do Dador
            var espermogramaAlvo = _context.Espermograma.SingleOrDefault(e => e.AmostraId == amostraAlvo.AmostraId);

            if (espermogramaAlvo == null)
            {
                return(NotFound());
            }

            // 4 - Preencher o objeto personalizado do dador para devolver ao Bot
            var dadorToReturn = new ModelDadorResEspermToBot
            {
                Nome             = dadorAlvo.Nome,
                DocIdentificacao = dadorAlvo.DocIdentificacao,
                AmostraId        = amostraAlvo.AmostraId,
                GrauA            = espermogramaAlvo.GrauA,
                GrauB            = espermogramaAlvo.GrauB,
                GrauC            = espermogramaAlvo.GrauC,
                GrauD            = espermogramaAlvo.GrauD
            };

            return(Ok(dadorToReturn));
        }
        // GET: ResultadoAnalises
        public IActionResult Index()
        {
            var allDadores = _encryptor.DecryptDataList(_context.Dador.ToList());
            ICollection <PedidoAnaliseViewModel> listDadoresAmostrasPendentes = new List <PedidoAnaliseViewModel>();

            foreach (var d in allDadores)
            {
                var amostraDadorPendente = _context.Amostra
                                           .Where(a => a.DadorId == d.DadorId)
                                           .Where(a => a.EstadoAmostra == EstadoAmostraEnum.PorAnalisar)
                                           .Where(a => a.TipoAmostra == TipoAmostraEnum.Sangue)
                                           .Select(s => new PedidoAnaliseViewModel {
                    NomeDador = d.Nome, AmostraId = s.AmostraId, EstadoAmostra = s.EstadoAmostra
                })
                                           .FirstOrDefault();

                if (amostraDadorPendente != null)
                {
                    listDadoresAmostrasPendentes.Add(amostraDadorPendente);
                }
            }

            return(View(listDadoresAmostrasPendentes));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Nome,DocIdentificacao,QuestionarioId,Perguntas,Respostas")] InqueritoAssistenteSocialViewModel inqueritoAssistenteSocialViewModel)
        {
            if (id != inqueritoAssistenteSocialViewModel.QuestionarioId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    IList <Dador> todosDadores = _encryptorDador.DecryptDataList(await _context.Dador.ToListAsync());

                    Dador dador = todosDadores.Where(d => d.Nome == inqueritoAssistenteSocialViewModel.Nome).Where(d => d.DocIdentificacao == inqueritoAssistenteSocialViewModel.DocIdentificacao).SingleOrDefault();
                    //Dador dadorInit = await _context.Dador.Where(d => d.Nome == encryptNome).Where(d => d.DocIdentificacao == encryptDocId).SingleOrDefaultAsync();

                    if (dador == null)
                    {
                        return(RedirectToAction(nameof(NotRegistered)));
                    }

                    List <Pergunta> perguntas = await _context.Pergunta.Where(p => p.QuestionarioId == inqueritoAssistenteSocialViewModel.QuestionarioId).Include(p => p.Respostas).ToListAsync();

                    bool rExists = perguntas.Any(p => p.Respostas.Where(r => r.DadorId == dador.DadorId).Any());

                    if (rExists)
                    {
                        return(RedirectToAction(nameof(AlreadyAnswered)));
                    }

                    for (int i = 0; i < perguntas.Count; i++)
                    {
                        Resposta resposta = new Resposta
                        {
                            DadorId       = dador.DadorId,
                            Dador         = dador,
                            PerguntaId    = perguntas[i].PerguntaId,
                            Pergunta      = perguntas[i],
                            TextoResposta = inqueritoAssistenteSocialViewModel.Respostas[i]
                        };

                        _context.Add(resposta);
                    }

                    //Analyze sentiment CORRIGIR
                    bool valido = await ValidarSentimentosAsync(inqueritoAssistenteSocialViewModel.Perguntas, inqueritoAssistenteSocialViewModel.Respostas);

                    if (valido)
                    {
                        List <double?> sentimentScores = _textEmotionService.AnalyzeEmotion(inqueritoAssistenteSocialViewModel.Respostas.FindAll(r => !r.Equals("Sim") && !r.Equals("Nao")));

                        // Invalid
                        if (sentimentScores.Exists(s => s < 0.3))
                        {
                            //Invalido
                            dador.ValidacaoInqueritoAS = ValidacaoEnum.Rejeitado;

                            _context.Update(_encryptorDador.EncryptData(dador));
                        }
                        else
                        {
                            // Valido
                            dador.ValidacaoInqueritoAS = ValidacaoEnum.Aceite;

                            _context.Update(_encryptorDador.EncryptData(dador));
                        }
                    }
                    else
                    {
                        dador.ValidacaoInqueritoAS = ValidacaoEnum.Rejeitado;

                        _context.Update(_encryptorDador.EncryptData(dador));
                    }

                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!QuestionarioExists(inqueritoAssistenteSocialViewModel.QuestionarioId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }

                return(RedirectToAction("IndexAnsweredAS", "Home"));
            }
            return(View(inqueritoAssistenteSocialViewModel));
        }
 // GET: ValidacaoCicloDadiva
 public async Task <IActionResult> Index()
 {
     return(View(_encryptor.DecryptDataList(await _context.Dador.Where(d => d.DadosDador == ValidacaoEnum.Aceite).Where(d => d.EstadoDador == EstadoDadorEnum.PendenteAprovacao).ToListAsync())));
 }
 // GET: ConsultaDestinosGametas
 public async Task <IActionResult> Index()
 {
     return(View(_encryptor.DecryptDataList(await _context.Dador
                                            .Where(d => d.Amostras.Any(a => a.EstadoAmostra == EstadoAmostraEnum.Enviada))
                                            .ToListAsync())));
 }
 // GET: Dadors
 public async Task <IActionResult> Index()
 {
     return(View(_encryptor.DecryptDataList(await _context.Dador.ToListAsync())));
 }