public ActionResult SelecionarAlunos(int idAula, int idModulo)
        {
            Med    med    = new MAula().BringOne(c => c.idAula == idAula).Turma.Med;
            Modulo modulo = new MModulo().BringOne(c => c.idModulo == idModulo);
            Aula   aula   = new MAula().BringOne(c => c.idAula == idAula);
            Turma  turma  = aula.Turma;
            List <InscricaoTurma>            alunosInscritos = new MInscricaoTurma().Bring(c => c.idTurma == turma.idTurma);
            List <SelecionarAlunosViewModel> viewModel       = new List <SelecionarAlunosViewModel>();
            MControleNotas      mControleNotas      = new MControleNotas();
            MControleNotasXAula mControleNotasXAula = new MControleNotasXAula();

            foreach (var inscrito in alunosInscritos)
            {
                ControleNotas controleNotas = mControleNotas.BringOne(c => (c.idInscricaoTurma == inscrito.idInscricaoTurma) && (c.idModulo == idModulo));
                if (controleNotas == null)
                {
                    controleNotas = new ControleNotas()
                    {
                        idModulo = idModulo, idInscricaoTurma = inscrito.idInscricaoTurma
                    };
                    mControleNotas.Add(controleNotas);
                }
                ControleNotasXAula        controleNotasXAula = mControleNotasXAula.BringOne(c => (c.idAula == idAula) && (c.idControleNotas == controleNotas.idControleNotas));
                SelecionarAlunosViewModel novo = new SelecionarAlunosViewModel();
                novo.inscricao = inscrito;
                if (controleNotasXAula != null)
                {
                    novo.nota = controleNotasXAula.nota;
                }
                viewModel.Add(novo);
            }
            ViewData["Aula"]   = aula;
            ViewData["Modulo"] = modulo;
            return(View(viewModel));
        }
Esempio n. 2
0
        public ActionResult CriarAvaliacao(AvaliacaoTutoria novaAvaliacao, int idModulo)
        {
            MAvaliacaoTutoria     mAvaliacaoTutoria = new MAvaliacaoTutoria();
            Grupo                 grupo             = new MGrupo().BringOne(c => c.idGrupo == novaAvaliacao.idGrupo);
            List <InscricaoTurma> alunosInscritos   = grupo.InscricaoTurma.ToList();
            MControleNotas        mControleNotas    = new MControleNotas();

            foreach (var inscrito in alunosInscritos)
            {
                ControleNotas controleNotas = mControleNotas.BringOne(c => (c.idInscricaoTurma == inscrito.idInscricaoTurma) && (c.idModulo == idModulo));
                if (controleNotas == null)
                {
                    controleNotas.idModulo         = idModulo;
                    controleNotas.idInscricaoTurma = inscrito.idInscricaoTurma;
                    mControleNotas.Add(controleNotas);
                }
                AvaliacaoTutoria avaliacaoAluno = new AvaliacaoTutoria();
                avaliacaoAluno.dtFim           = novaAvaliacao.dtFim;
                avaliacaoAluno.dtInicio        = novaAvaliacao.dtInicio;
                avaliacaoAluno.idControleNotas = controleNotas.idControleNotas;
                avaliacaoAluno.idGrupo         = grupo.idGrupo;
                avaliacaoAluno.idProblemaxMed  = novaAvaliacao.idProblemaxMed;
                mAvaliacaoTutoria.Add(avaliacaoAluno);
            }
            List <AvaliacaoTutoria> avaliacoesTutoria = mAvaliacaoTutoria.Bring(c => (c.idGrupo == grupo.idGrupo) && (c.idProblemaxMed == novaAvaliacao.idProblemaxMed));

            TempData["avaliacoes"] = avaliacoesTutoria;
            return(RedirectToAction("SelecionarAluno", "GerenciarProblemasMinistados"));
        }
Esempio n. 3
0
        public ActionResult Index()
        {
            int     idUsuario = Convert.ToInt32(HttpContext.User.Identity.Name);
            Usuario user      = new MUsuario().BringOne(c => c.idUsuario == idUsuario);
            Aluno   aluno     = user.Aluno.FirstOrDefault();
            List <InscricaoTurma>             turmasAluno    = aluno.InscricaoTurma.ToList();
            MControleNotas                    mControleNotas = new MControleNotas();
            List <ListagemMedsAlunoViewModel> viewModel      = new List <ListagemMedsAlunoViewModel>();

            foreach (var med in turmasAluno)
            {
                var itemAdciononar = new ListagemMedsAlunoViewModel
                {
                    descMed         = med.Turma.Med.descMed,
                    descSemestre    = med.ControleNotas.FirstOrDefault().Modulo.Semestre.descSemestre,
                    idMed           = med.Turma.idMed,
                    notas           = new double[] { 0, 0, 0 },
                    idControleNotas = new int[] { 0, 0, 0 }
                };
                for (int i = 0; i < med.ControleNotas.Count; i++)
                {
                    itemAdciononar.notas[i]           = mControleNotas.RetornaNota(med.ControleNotas.ElementAt(i).idControleNotas);
                    itemAdciononar.idControleNotas[i] = med.ControleNotas.ElementAt(i).idControleNotas;
                }
                viewModel.Add(itemAdciononar);
            }
            return(View(viewModel));
        }
Esempio n. 4
0
        public ActionResult DetalhesModulo(int idControleNotas)
        {
            var            viewModel      = new DetalhesModuloAlunoViewModel();
            MControleNotas mControleNotas = new MControleNotas();
            ControleNotas  controleNotas  = mControleNotas.BringOne(c => c.idControleNotas == idControleNotas);

            viewModel.descModulo = controleNotas.InscricaoTurma.Turma.Med.descMed + " - " + controleNotas.InscricaoTurma.Turma.Med.Semestre.descSemestre + " - " + controleNotas.Modulo.descModulo;
            viewModel.notaSimuladoMorfofuncional = mControleNotas.retornaNotaSimulado(controleNotas.idControleNotas, controleNotas.ControleNotasXProva.Where(c => c.Prova.idTipoProva == (int)Enumeradores.TipoProva.Morfofuncional).Select(c => c.idProva).FirstOrDefault());
            viewModel.notaSimuladoTutoria        = mControleNotas.retornaNotaSimulado(controleNotas.idControleNotas, controleNotas.ControleNotasXProva.Where(c => c.Prova.idTipoProva == (int)Enumeradores.TipoProva.Tutoria).Select(c => c.idProva).FirstOrDefault());
            viewModel.disciplinas = new List <DetalhesDisciplinaAlunoViewModel>();
            foreach (var disciplina in controleNotas.ControleNotasXAula)
            {
                viewModel.disciplinas.Add(new DetalhesDisciplinaAlunoViewModel()
                {
                    descDisciplina = disciplina.Aula.Disciplina.descDisciplina,
                    nota           = mControleNotas.retornaNotaDisciplina(disciplina.idAula, controleNotas.idControleNotas),
                    tipoAvaliacao  = disciplina.Aula.Disciplina.TipoDisciplina.descTipoDisciplina
                });
            }
            viewModel.problemas = new List <DetalhesProblemaAlunoViewModel>();
            foreach (var problema in controleNotas.AvaliacaoTutoria)
            {
                viewModel.problemas.Add(new DetalhesProblemaAlunoViewModel()
                {
                    tituloProblema = problema.ProblemaXMed.Problema.descProblema,
                    notaFinal      = mControleNotas.retornaNotaProblema(problema.idAvaliacaoTutoria)
                });
            }
            return(View(viewModel));
        }
Esempio n. 5
0
        public ActionResult GerenciarNotas(int idMed)
        {
            Med med = new MMed().BringOne(c => c.idMed == idMed);

            ViewBag.idMed           = idMed;
            ViewBag.descMedSemestre = med.descMed + " - " + med.Semestre.descSemestre;
            List <Turma>          listTurmas          = new MTurma().Bring(c => c.idMed == idMed);
            List <InscricaoTurma> listAlunosInscritos = new List <InscricaoTurma>();
            MInscricaoTurma       mInscricaoTurma     = new MInscricaoTurma();

            foreach (var turma in listTurmas)
            {
                listAlunosInscritos.AddRange(mInscricaoTurma.Bring(c => c.idTurma == turma.idTurma));
            }
            List <GerenciarNotasViewModel> listGerenciaNotas = new List <GerenciarNotasViewModel>();
            MControleNotas mControleNotas = new MControleNotas();

            foreach (var alunoInscrito in listAlunosInscritos)
            {
                GerenciarNotasViewModel notasAluno = new GerenciarNotasViewModel();
                notasAluno.controleNotas = new List <ControleNotasViewModel>();
                foreach (var controleNotas in alunoInscrito.ControleNotas)
                {
                    notasAluno.controleNotas.Add(new ControleNotasViewModel()
                    {
                        controleNotas = controleNotas,
                        nota          = mControleNotas.RetornaNota(controleNotas.idControleNotas)
                    });
                }
                notasAluno.aluno = alunoInscrito;
                listGerenciaNotas.Add(notasAluno);
            }
            return(View(listGerenciaNotas));
        }
        public ActionResult AcompanharMed(int idInscricaoTurma, int idMed)
        {
            List <ControleNotas> listControleNotas = new MControleNotas().Bring(c => (c.idInscricaoTurma == idInscricaoTurma));
            int numDisciplinasPraticas             = new MMed().BringOne(c => c.idMed == idMed).Disciplina.Where(c => c.idTipoDisciplina == 2).Count();
            int numDisciplinasMorfofuncionais      = new MMed().BringOne(c => c.idMed == idMed).Disciplina.Where(c => c.idTipoDisciplina == 1).Count();

            foreach (ControleNotas modulo in listControleNotas)
            {
                var disciplinasPraticas        = modulo.ControleNotasXAula.Where(c => c.Aula.Disciplina.idTipoDisciplina == 2).Sum(c => c.nota);
                var disciplinasMorfofuncionais = modulo.ControleNotasXAula.Where(c => c.Aula.Disciplina.idTipoDisciplina == 1).Sum(c => c.nota);
                var ProvaoTutoria = modulo.ControleNotasXProva.Where(c => c.Prova.idTipoProva == 1).Select(c => (c.Prova.valorQuestao * c.numAcertos));
                var ProvaoPratica = modulo.ControleNotasXProva.Where(c => c.Prova.idTipoProva == 2).Select(c => (c.Prova.valorQuestao * c.numAcertos));
            }
            return(View(listControleNotas));
        }
        public ActionResult AvaliarAluno(int idInscricaoTurma, int idModulo, int idAula)
        {
            Med    med    = new MAula().BringOne(c => c.idAula == idAula).Turma.Med;
            Modulo modulo = new MModulo().BringOne(c => c.idModulo == idModulo);
            Aula   aula   = new MAula().BringOne(c => c.idAula == idAula);

            ViewData["Aula"]   = aula;
            ViewData["Modulo"] = modulo;
            ViewData["Aluno"]  = new MInscricaoTurma().BringOne(c => c.idInscricaoTurma == idInscricaoTurma).Aluno;
            ControleNotas      controleNotas     = new MControleNotas().BringOne(c => (c.idInscricaoTurma == idInscricaoTurma) && (c.idModulo == idModulo));
            ControleNotasXAula controleNotasAula = new ControleNotasXAula();

            controleNotasAula.idAula = idAula;
            //controleNotasAula.nota = nota;
            controleNotasAula.idControleNotas = controleNotas.idControleNotas;
            MControleNotasXAula mControleNotasXAula = new MControleNotasXAula();

            return(View(controleNotasAula));
        }
        public ActionResult CriarAvaliacao(AvaliacaoTutoria novaAvaliacao, int idModulo)
        {
            MAvaliacaoTutoria     mAvaliacaoTutoria = new MAvaliacaoTutoria();
            Grupo                 grupo             = new MGrupo().BringOne(c => c.idGrupo == novaAvaliacao.idGrupo);
            List <InscricaoTurma> alunosInscritos   = grupo.InscricaoTurma.ToList();
            MControleNotas        mControleNotas    = new MControleNotas();

            foreach (var inscrito in alunosInscritos)
            {
                ControleNotas controleNotas = mControleNotas.BringOne(c => (c.idInscricaoTurma == inscrito.idInscricaoTurma) && (c.idModulo == idModulo));
                if (controleNotas == null)
                {
                    controleNotas.idModulo         = idModulo;
                    controleNotas.idInscricaoTurma = inscrito.idInscricaoTurma;
                    mControleNotas.Add(controleNotas);
                }
                var teste = (inscrito.ControleNotas.Select(c => c.AvaliacaoTutoria.Where(x => x.idProblemaxMed == novaAvaliacao.idProblemaxMed))).FirstOrDefault().FirstOrDefault();
                AvaliacaoTutoria avaliacaoAluno = teste;
                if (avaliacaoAluno == null)
                {
                    avaliacaoAluno                 = new AvaliacaoTutoria();
                    avaliacaoAluno.dtFim           = novaAvaliacao.dtFim;
                    avaliacaoAluno.dtInicio        = novaAvaliacao.dtInicio;
                    avaliacaoAluno.idControleNotas = controleNotas.idControleNotas;
                    avaliacaoAluno.idGrupo         = grupo.idGrupo;
                    avaliacaoAluno.idProblemaxMed  = novaAvaliacao.idProblemaxMed;
                    mAvaliacaoTutoria.Add(avaliacaoAluno);
                }
                else
                {
                    avaliacaoAluno.dtFim           = novaAvaliacao.dtFim;
                    avaliacaoAluno.dtInicio        = novaAvaliacao.dtInicio;
                    avaliacaoAluno.idControleNotas = controleNotas.idControleNotas;
                    avaliacaoAluno.idGrupo         = grupo.idGrupo;
                    avaliacaoAluno.idProblemaxMed  = novaAvaliacao.idProblemaxMed;
                    mAvaliacaoTutoria.Update(avaliacaoAluno);
                }
            }
            List <AvaliacaoTutoria> avaliacoesTutoria = mAvaliacaoTutoria.Bring(c => (c.idGrupo == grupo.idGrupo) && (c.idProblemaxMed == novaAvaliacao.idProblemaxMed));

            return(RedirectToAction("SelecionarAluno", "GerenciarProblemasMinistrados", new { idProblemaXMed = novaAvaliacao.idProblemaxMed, idGrupo = grupo.idGrupo }));
        }
Esempio n. 9
0
        public ActionResult AdicionarAlunosTurmaAction(int idTurma)
        {
            var                   alunos          = Request.Form["alunos[]"].Split(',');
            List <Aluno>          listAlunos      = new List <Aluno>();
            MAluno                mAluno          = new MAluno();
            Turma                 turma           = new MTurma().BringOne(c => c.idTurma == idTurma);
            MInscricaoTurma       mInscricaoTurma = new MInscricaoTurma();
            List <InscricaoTurma> alunosInscritos = mInscricaoTurma.Bring(c => c.idTurma == turma.idTurma);
            List <InscricaoTurma> alunosInscrever = new List <InscricaoTurma>();
            MControleNotas        mControleNotas  = new MControleNotas();

            foreach (var item in alunos)
            {
                InscricaoTurma novo = new InscricaoTurma();
                novo.idAluno = Convert.ToInt32(item);
                novo.idTurma = turma.idTurma;
                alunosInscrever.Add(novo);
            }
            foreach (var item in alunosInscritos)
            {
                if (alunosInscrever.SingleOrDefault(c => c.idAluno == item.idAluno) == null)
                {
                    mInscricaoTurma.Delete(item);
                }
            }
            foreach (var item in alunosInscrever)
            {
                if (alunosInscritos.SingleOrDefault(c => (c.idAluno == item.idAluno) && (c.idTurma == idTurma)) != null)
                {
                    continue;
                }
                mInscricaoTurma.Add(item);
                foreach (var modulo in turma.Med.Semestre.Modulo)
                {
                    ControleNotas controleNotas = new ControleNotas();
                    controleNotas.idInscricaoTurma = item.idInscricaoTurma;
                    controleNotas.idModulo         = modulo.idModulo;
                    mControleNotas.Add(controleNotas);
                }
            }
            return(RedirectToAction("GerenciarTurmas", new { idMed = turma.idMed }));
        }
        public ActionResult AdicionarAlunosTurmaAction(int idAluno, int idTurma)
        {
            InscricaoTurma novo = new InscricaoTurma();

            novo.idTurma = idTurma;
            novo.idAluno = idAluno;
            new MInscricaoTurma().Add(novo);
            MControleNotas mControleNotas = new MControleNotas();

            Turma turma = new MTurma().BringOne(c => c.idTurma == idTurma);

            foreach (var item in turma.Med.Semestre.Modulo)
            {
                ControleNotas controleNotas = new ControleNotas();
                controleNotas.idInscricaoTurma = novo.idInscricaoTurma;
                controleNotas.idModulo         = item.idModulo;
                mControleNotas.Add(controleNotas);
            }
            return(AdicionarAlunosTurma(idTurma));
        }
        public ActionResult SelecionarAluno(int idProblemaXMed, int idGrupo)
        {
            var mAvaliacaoTutoria = new MAvaliacaoTutoria();
            List <AvaliacaoTutoria>         avaliacoes = mAvaliacaoTutoria.Bring(c => (c.idProblemaxMed == idProblemaXMed) && (c.idGrupo == idGrupo));
            ListarAvaliacaoTutoriaViewModel viewModel  = new ListarAvaliacaoTutoriaViewModel();

            viewModel.alunosAvaliados    = new List <AvaliacaoTutoria>();
            viewModel.alunosNaoAvaliados = new List <AvaliacaoTutoria>();
            Grupo    grupo    = new MGrupo().BringOne(c => c.idGrupo == idGrupo);
            Problema problema = new MProblemaXMed().BringOne(c => c.idProblemaxMed == idProblemaXMed).Problema;

            ViewBag.Informativo = problema.tituloProblema + " - " + grupo.descGrupo;

            if (avaliacoes.Count == 0)
            {
                return(RedirectToAction("MontarFichaAvaliativa", new { idProblemaXMed = idProblemaXMed, idGrupo = idGrupo }));
            }
            int      idModulo            = (int)avaliacoes.FirstOrDefault().ControleNotas.idModulo;
            DateTime dataFimAvaliacao    = avaliacoes.FirstOrDefault().dtFim;
            DateTime dataInicioAvaliacao = avaliacoes.FirstOrDefault().dtInicio;

            if (grupo.InscricaoTurma.Count != avaliacoes.Count)
            {
                List <InscricaoTurma> alunosInscritos = grupo.InscricaoTurma.ToList();
                MControleNotas        mControleNotas  = new MControleNotas();
                foreach (InscricaoTurma alunoInscrito in alunosInscritos)
                {
                    ControleNotas controleNotas = alunoInscrito.ControleNotas.SingleOrDefault(c => c.idModulo == idModulo);
                    if (controleNotas == null)
                    {
                        controleNotas.idModulo         = idModulo;
                        controleNotas.idInscricaoTurma = alunoInscrito.idInscricaoTurma;
                        mControleNotas.Add(controleNotas);
                        AvaliacaoTutoria avaliacaoAluno = new AvaliacaoTutoria();
                        avaliacaoAluno.dtFim           = dataFimAvaliacao;
                        avaliacaoAluno.dtInicio        = dataInicioAvaliacao;
                        avaliacaoAluno.idControleNotas = controleNotas.idControleNotas;
                        avaliacaoAluno.idGrupo         = grupo.idGrupo;
                        avaliacaoAluno.idProblemaxMed  = idProblemaXMed;
                        mAvaliacaoTutoria.Add(avaliacaoAluno);
                    }
                    else
                    {
                        if (alunoInscrito.ControleNotas.SingleOrDefault(c => c.idModulo == idModulo).AvaliacaoTutoria.SingleOrDefault(c => c.idProblemaxMed == idProblemaXMed) == null)
                        {
                            AvaliacaoTutoria avaliacaoAluno = new AvaliacaoTutoria();
                            avaliacaoAluno.dtFim           = dataFimAvaliacao;
                            avaliacaoAluno.dtInicio        = dataInicioAvaliacao;
                            avaliacaoAluno.idControleNotas = controleNotas.idControleNotas;
                            avaliacaoAluno.idGrupo         = grupo.idGrupo;
                            avaliacaoAluno.idProblemaxMed  = idProblemaXMed;
                            mAvaliacaoTutoria.Add(avaliacaoAluno);
                        }
                    }
                }
            }



            int       idUsuario = Convert.ToInt32(HttpContext.User.Identity.Name);
            Usuario   user      = new MUsuario().BringOne(c => c.idUsuario == idUsuario);
            Professor prof      = user.Professor.First();

            if (grupo.idProfessor != prof.idProfessor)
            {
                return(View(viewModel));
            }
            if (avaliacoes == null)
            {
                avaliacoes = new List <AvaliacaoTutoria>();
            }
            foreach (AvaliacaoTutoria item in avaliacoes)
            {
                if (item.FichaAvaliacao.Where(c => c.idAvaliador == idUsuario).FirstOrDefault() != null)
                {
                    if (item.FichaAvaliacao.Where(c => c.idAvaliador == idUsuario).FirstOrDefault().PerguntaXFicha.Where(c => c.marcado != null).Count() == 9)
                    {
                        viewModel.alunosAvaliados.Add(item);
                    }
                    else
                    {
                        viewModel.alunosNaoAvaliados.Add(item);
                    }
                }
                else
                {
                    viewModel.alunosNaoAvaliados.Add(item);
                }
            }
            return(View(viewModel));
        }