Пример #1
0
        public async Task <IActionResult> PutDica(Guid id, Dica dica)
        {
            if (id != dica.IdDica)
            {
                return(BadRequest());
            }

            _context.Entry(dica).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!DicaExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #2
0
        public async Task <IActionResult> PutUsuario(int id, Usuario usuario)
        {
            if (id != usuario.IdUsuario)
            {
                return(BadRequest());
            }

            _context.Entry(usuario).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UsuarioExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Пример #3
0
        public async Task <Ranking> SomarNotaRankingAluno(ObjetivoAluno _aluno, AlunoTurma _alunoTurma)
        {
            try
            {
                //Buscando os dados do Usuario de acordo com o IdUsuairo inserindo no objeto alunoTurma
                Usuario usuario = _repositoryUsuario.BuscarUsuarioPorId((int)_alunoTurma.IdUsuario);

                //Procurando o ranking do aluno para poder alterar sua nota
                Ranking _rankingProcurado = BuscarRankingDoAluno(usuario.Nome);

                //Adicionando a nota atribuida ao objetivo concluido a sua nota geral do ranking
                _rankingProcurado.NotaTotal += _aluno.Nota;

                //Buscando os dados do Objetivo concluido para verficarmos se o mesmo é um objetivo oculto
                Objetivo _objetivo = _repositoryObjetivo.BuscarObjetivoPorId((int)_aluno.IdObjetivo);

                //Caso seja um objetivo oculto, somaremos a quantidade de objetivos oculto concluidos do aluno
                if (_objetivo.IdCategoria == 3)
                {
                    _rankingProcurado.ObjetivosOculto += 1;
                }

                //Salvando as alterações da nota do aluno
                _contexto.Entry(_rankingProcurado).State = EntityState.Modified;

                await _contexto.SaveChangesAsync();

                return(_rankingProcurado);
            }catch (Exception _e)
            {
                throw new Exception(_e.Message);
            }
        }
        public async Task <IActionResult> PutInstituicao(Guid id, Instituicao instituicao)
        {
            if (id != instituicao.IdInstituicao)
            {
                return(BadRequest());
            }

            _context.Entry(instituicao).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!InstituicaoExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutObjetivoAluno(Guid id, ObjetivoAluno objetivoAluno)
        {
            if (id != objetivoAluno.IdOjetivoAluno)
            {
                return(BadRequest());
            }

            _context.Entry(objetivoAluno).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ObjetivoAlunoExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <Usuarios> CadastrarUsuario(Usuarios _usuario)
        {
            try
            {
                await _contexto.Usuarios.AddAsync(_usuario);

                if (_usuario.IdPerfilNavigation.Permissao == "Professor")
                {
                    foreach (ProfessoresTurmas _turmaProfessor in _usuario.ProfessoresTurmas)
                    {
                        _usuario.ProfessoresTurmas.Add(new ProfessoresTurmas {
                            IdUsuario = _usuario.Id,
                            IdTurma   = _turmaProfessor.Id
                        });
                    }
                }

                if (_usuario.IdPerfilNavigation.Permissao == "Aluno")
                {
                    foreach (AlunosTurmas _turmaAluno in _usuario.AlunosTurmas)
                    {
                        _usuario.AlunosTurmas.Add(new AlunosTurmas {
                            IdUsuario = _usuario.Id,
                            IdTurma   = _turmaAluno.Id
                        });
                    }
                }

                await _contexto.SaveChangesAsync();

                return(_usuario);
            }catch (Exception _e) {
                throw new Exception(_e.Message);
            }
        }
        public async Task <Perfils> CadastrarPerfil(Perfils _perfil)
        {
            try
            {
                await _contexto.Perfils.AddAsync(_perfil);

                await _contexto.SaveChangesAsync();

                return(_perfil);
            }catch (Exception _e) {
                throw new Exception(_e.Message);
            }
        }
        public async Task <ObjetivoAluno> CadastrarObjetivosDoAluno(ObjetivoAluno _objetivoAluno)
        {
            try
            {
                _objetivoAluno.DataAlcancado = DateTime.Now;

                await _contexto.ObjetivoAluno.AddAsync(_objetivoAluno);

                await _contexto.SaveChangesAsync();

                //Buscando a turma do aluno de acordo com o objetivo concluido para verificarmos sua nota geral
                AlunoTurma _alunoTurma = _alunoTurmaRepository.BuscarAlunoTurmaPorId((int)_objetivoAluno.IdAlunoTurma);

                //Passando os dados da turma do aluno e da sua nota atingida para computarmos sua nota geral
                await _rankingRepository.SomarNotaRankingAluno(_objetivoAluno, _alunoTurma);

                return(_objetivoAluno);
            }
            catch (Exception _e)
            {
                throw new Exception(_e.Message);
            }
        }