Ejemplo n.º 1
0
        public async Task <IActionResult> CarregaCurso(int id)
        {
            try
            {
                //Retorna os dados da inscricao
                var retornoDadosInscricao = await _inscricaoUsuarioRepository.ObterPorId(id);

                if (retornoDadosInscricao.UsuarioId != Convert.ToInt32(User.Identity.Name))
                {
                    return(Response("Busca invalida", false));
                }

                //Obter lista prova realizado
                var listaProvaUsuario = await _provaUsuarioRepository.Buscar(x => x.UsuarioId.Equals(Convert.ToInt32(User.Identity.Name)));

                //Busca o ultimo conteudo do usuario
                var retornoConteudoUsuario = await _conteudoUsuarioRepository.Buscar(x => x.UsuariosId == Convert.ToInt32(User.Identity.Name) && x.Conteudo.Modulo.CursoId == retornoDadosInscricao.ProcessoInscricao.CursoId);

                var _cursoService = new CursoService(_moduloRepository, _conteudoUsuarioRepository, Convert.ToInt32(User.Identity.Name));

                if (retornoConteudoUsuario.Length > 0)
                {
                    var ultimoConteudo = retornoConteudoUsuario.OrderByDescending(c => c.DataConclusao).Select(c => c.Conteudo).FirstOrDefault();

                    await _cursoService.SalvarVisualizacaoUsuario(ultimoConteudo.Id);

                    _cursoService.PreenchConteudoConcluido(ultimoConteudo, listaProvaUsuario);

                    return(Response(_mapper.Map <ConteudoDto>(ultimoConteudo)));
                }

                var ultimoConteudoVisualizado = retornoDadosInscricao.ProcessoInscricao.Curso.Modulo.FirstOrDefault().Conteudos[0];

                await _cursoService.SalvarVisualizacaoUsuario(ultimoConteudoVisualizado.Id);

                _cursoService.PreenchConteudoConcluido(ultimoConteudoVisualizado, listaProvaUsuario);

                return(Response(_mapper.Map <ConteudoDto>(ultimoConteudoVisualizado)));
            }
            catch (Exception ex)
            {
                return(ResponseErro(ex));
            }
        }
        public async Task <IActionResult> ProcessarCursoInscrito(int id)
        {
            try
            {
                var response = await _inscricaoUsuarioRepository.ObterPorId(id);

                if (response.UsuarioId != Convert.ToInt32(User.Identity.Name))
                {
                    return(Response("Busca invalida", false));
                }

                var listaProvaUsuario = await _provaUsuarioRepository.Buscar(x => x.UsuarioId.Equals(Convert.ToInt32(User.Identity.Name)));

                foreach (var modulo in response.ProcessoInscricao.Curso.Modulo)
                {
                    foreach (var conteudo in modulo.Conteudos)
                    {
                        if (conteudo.Tipo.Equals("PR") || conteudo.Tipo.Equals("PA"))
                        {
                            var provaUsuario = listaProvaUsuario.Where(x => x.Prova.ConteudoId.Equals(conteudo.Id)).ToList();

                            if (provaUsuario.Count > 0)
                            {
                                conteudo.ConteudoConcluido = true;
                            }
                            else
                            {
                                conteudo.ConteudoConcluido = false;
                            }
                        }
                        else
                        {
                            conteudo.ConteudoConcluido = conteudo.ConteudoUsuarios.Exists(x => x.ConteudoId == conteudo.Id && x.UsuariosId == Convert.ToInt32(User.Identity.Name) && x.Concluido.Equals("S"));
                        }
                    }
                }


                return(Response(response));
            }
            catch (Exception ex)
            {
                return(ResponseErro(ex));
            }
        }
Ejemplo n.º 3
0
        public async Task <IActionResult> BuscarModuloCurso(int idCurso)
        {
            try
            {
                var retorno = await _moduloRepository.Buscar(x => x.CursoId.Equals(idCurso));

                var listaProvaUsuario = await _provaUsuarioRepository.Buscar(x => x.UsuarioId.Equals(Convert.ToInt32(User.Identity.Name)));

                foreach (var modulo in retorno)
                {
                    foreach (var conteudo in modulo.Conteudos)
                    {
                        if (conteudo.Tipo.Equals("PR") || conteudo.Tipo.Equals("PA"))
                        {
                            var provaUsuario = listaProvaUsuario.Where(x => x.Prova.ConteudoId.Equals(conteudo.Id)).ToList();

                            if (provaUsuario.Count > 0)
                            {
                                conteudo.ConteudoConcluido = true;
                            }
                            else
                            {
                                conteudo.ConteudoConcluido = false;
                            }
                        }
                        else
                        {
                            conteudo.ConteudoConcluido = conteudo.ConteudoUsuarios.Exists(x => x.ConteudoId == conteudo.Id && x.UsuariosId == Convert.ToInt32(User.Identity.Name) && x.Concluido.Equals("S"));
                        }
                    }
                }

                return(Response(retorno));
            }
            catch (Exception ex)
            {
                return(ResponseErro(ex));
            }
        }