コード例 #1
0
        public ActionResult Gerar(FormCollection form)
        {
            if (!StringExt.IsNullOrWhiteSpace(form["txtTitulo"], form["txtObjetivo"]))
            {
                var avi = new AvalAvi();
                /* Chave */
                avi.Avaliacao = new Avaliacao();
                DateTime hoje = DateTime.Now;
                avi.Avaliacao.TipoAvaliacao    = TipoAvaliacao.ListarPorCodigo(TipoAvaliacao.AVI);
                avi.Avaliacao.Ano              = hoje.Year;
                avi.Avaliacao.Semestre         = hoje.SemestreAtual();
                avi.Avaliacao.NumIdentificador = Avaliacao.ObterNumIdentificador(TipoAvaliacao.AVI);
                avi.Avaliacao.DtCadastro       = hoje;
                avi.Avaliacao.FlagLiberada     = false;

                /* AVI */
                avi.Titulo   = form["txtTitulo"];
                avi.Objetivo = form["txtObjetivo"];

                /* Colaborador */
                Colaborador colaborador = Colaborador.ListarPorMatricula(Sessao.UsuarioMatricula);
                avi.CodColabCoordenador = colaborador.CodColaborador;
                avi.Colaborador         = colaborador;

                AvalAvi.Inserir(avi);
                Lembrete.AdicionarNotificacao($"Avaliação Institucional cadastrada com sucesso.", Lembrete.POSITIVO);
                return(RedirectToAction("Questionario", new { codigo = avi.Avaliacao.CodAvaliacao }));
            }
            return(RedirectToAction("Gerar"));
        }
コード例 #2
0
        private TipoAvaliacao MapearDtoParaEntidade(TipoAvaliacaoDto dto, long id)
        {
            TipoAvaliacao tipoAtividadeAvaliativa = new TipoAvaliacao();

            if (id > 0L)
            {
                tipoAtividadeAvaliativa = repositorioTipoAvaliacao.ObterPorId(id);
            }
            tipoAtividadeAvaliativa.Nome      = dto.Nome;
            tipoAtividadeAvaliativa.Descricao = dto.Descricao;
            tipoAtividadeAvaliativa.Situacao  = dto.Situacao;
            return(tipoAtividadeAvaliativa);
        }
コード例 #3
0
 private TipoAvaliacaoCompletaDto MapearParaDto(TipoAvaliacao tipoAvaliacao, bool?possuiAvaliacaoVinculada)
 {
     return(tipoAvaliacao == null ? null : new TipoAvaliacaoCompletaDto
     {
         Id = tipoAvaliacao.Id,
         Nome = tipoAvaliacao.Nome,
         Descricao = tipoAvaliacao.Descricao,
         Situacao = tipoAvaliacao.Situacao,
         AlteradoEm = tipoAvaliacao.AlteradoEm,
         AlteradoPor = tipoAvaliacao.AlteradoPor,
         AlteradoRF = tipoAvaliacao.AlteradoRF,
         CriadoEm = tipoAvaliacao.CriadoEm,
         CriadoPor = tipoAvaliacao.CriadoPor,
         CriadoRF = tipoAvaliacao.CriadoRF,
         possuiAvaliacao = possuiAvaliacaoVinculada,
         AvaliacoesNecessariasPorBimestre = tipoAvaliacao.AvaliacoesNecessariasPorBimestre,
     });
 }
コード例 #4
0
        public ActionResult Confirmar(FormCollection formCollection)
        {
            if (Sessao.UsuarioCategoriaCodigo != Categoria.PROFESSOR)
            {
                if (Session["UrlReferrer"] != null)
                {
                    return(Redirect(Session["UrlReferrer"].ToString()));
                }
                else
                {
                    return(RedirectToAction("Index", "Principal"));
                }
            }
            var acad = new AvalAcademica();

            if (formCollection.HasKeys())
            {
                DateTime hoje = DateTime.Now;

                /* Chave */
                acad.Avaliacao = new Avaliacao();
                acad.Avaliacao.TipoAvaliacao    = TipoAvaliacao.ListarPorCodigo(TipoAvaliacao.ACADEMICA);
                acad.Avaliacao.Ano              = hoje.Year;
                acad.Avaliacao.Semestre         = hoje.SemestreAtual();
                acad.Avaliacao.NumIdentificador = Avaliacao.ObterNumIdentificador(TipoAvaliacao.ACADEMICA);
                acad.Avaliacao.DtCadastro       = hoje;

                /* Professor */
                string matricula = Helpers.Sessao.UsuarioMatricula;
                acad.Professor = Professor.ListarPorMatricula(matricula);

                /* Dados */
                int codDisciplina = int.Parse(formCollection["ddlDisciplina"]);

                acad.CodDisciplina = codDisciplina;

                /* Dificuldade */
                int codDificuldade = int.Parse(formCollection["ddlDificuldade"]);

                /* Quantidade */
                int quantidadeObjetiva   = 0;
                int quantidadeDiscursiva = 0;

                if (formCollection["ddlTipo"] == "3")
                {
                    int.TryParse(formCollection["txtQteObjetiva"], out quantidadeObjetiva);
                    int.TryParse(formCollection["txtQteDiscursiva"], out quantidadeDiscursiva);
                }
                else if (formCollection["ddlTipo"] == "2")
                {
                    int.TryParse(formCollection["txtQteDiscursiva"], out quantidadeDiscursiva);
                }
                else if (formCollection["ddlTipo"] == "1")
                {
                    int.TryParse(formCollection["txtQteObjetiva"], out quantidadeObjetiva);
                }

                /* Temas */
                string[] temaCodigos = formCollection["ddlTemas"].Split(',');

                /* Questões */
                List <QuestaoTema> lstQuestoes = new List <QuestaoTema>();

                if (quantidadeObjetiva > 0)
                {
                    lstQuestoes.AddRange(Questao.ListarPorDisciplina(codDisciplina, temaCodigos, codDificuldade, TipoQuestao.OBJETIVA, quantidadeObjetiva));
                }
                if (quantidadeDiscursiva > 0)
                {
                    lstQuestoes.AddRange(Questao.ListarPorDisciplina(codDisciplina, temaCodigos, codDificuldade, TipoQuestao.DISCURSIVA, quantidadeDiscursiva));
                }

                foreach (var temaCodigo in temaCodigos)
                {
                    var avalTema = new AvaliacaoTema();
                    avalTema.Tema = Tema.ListarPorCodigo(codDisciplina, int.Parse(temaCodigo));
                    foreach (var questaoTema in lstQuestoes.Where(q => q.CodTema == int.Parse(temaCodigo)))
                    {
                        var avalTemaQuestao = new AvalTemaQuestao();
                        avalTemaQuestao.QuestaoTema = questaoTema;
                        avalTema.AvalTemaQuestao.Add(avalTemaQuestao);
                    }
                    acad.Avaliacao.AvaliacaoTema.Add(avalTema);
                }

                AvalAcademica.Inserir(acad);
                Lembrete.AdicionarNotificacao($"Avaliação Acadêmica {acad.Avaliacao.CodAvaliacao} gerada com sucesso.", Lembrete.POSITIVO);
                if (quantidadeObjetiva + quantidadeDiscursiva > acad.Avaliacao.Questao.Count)
                {
                    Lembrete.AdicionarNotificacao("Avaliação Acadêmica gerada com quantidade de questões inferior ao requisitado", Lembrete.NEGATIVO, 0);
                }
            }

            return(View(acad));
        }
コード例 #5
0
        public ActionResult Confirmar(FormCollection formCollection)
        {
            if (!formCollection.HasKeys())
            {
                return(RedirectToAction("Index"));
            }

            if (!String.IsNullOrWhiteSpace(formCollection["chkAvalicoesSeparadas"]))
            {
                string[] disciplinas = formCollection["ddlDisciplinas"].Split(',');
                foreach (var disciplina in disciplinas)
                {
                    var auto = new AvalAuto();

                    DateTime hoje = DateTime.Now;

                    /* Chave */
                    auto.Avaliacao = new Avaliacao();
                    auto.Avaliacao.TipoAvaliacao    = TipoAvaliacao.ListarPorCodigo(TipoAvaliacao.AUTOAVALIACAO);
                    auto.Avaliacao.Ano              = hoje.Year;
                    auto.Avaliacao.Semestre         = hoje.SemestreAtual();
                    auto.Avaliacao.NumIdentificador = Avaliacao.ObterNumIdentificador(TipoAvaliacao.AUTOAVALIACAO);

                    /* Pessoa */
                    auto.CodPessoaFisica = Sistema.UsuarioAtivo[Sessao.UsuarioMatricula].Usuario.CodPessoaFisica;

                    /* Dados */
                    List <int> dificuldades = new List <int>();

                    /* Dificuldade */
                    int codDificuldade = int.Parse(formCollection["ddlDificuldade" + disciplina]);
                    dificuldades.Add(codDificuldade);

                    /* Quantidade */
                    int qteObjetiva   = 0;
                    int qteDiscursiva = 0;
                    if (formCollection["ddlTipo"] == "3")
                    {
                        int.TryParse(formCollection["txtQteObjetiva" + disciplina], out qteObjetiva);
                        int.TryParse(formCollection["txtQteDiscursiva" + disciplina], out qteDiscursiva);
                    }
                    else if (formCollection["ddlTipo"] == "2")
                    {
                        int.TryParse(formCollection["txtQteDiscursiva" + disciplina], out qteDiscursiva);
                    }
                    else if (formCollection["ddlTipo"] == "1")
                    {
                        int.TryParse(formCollection["txtQteObjetiva" + disciplina], out qteObjetiva);
                    }

                    /* Temas */
                    string[] temas = formCollection["ddlTemas" + disciplina].Split(',');

                    /* Questões */
                    List <QuestaoTema> questoes = new List <QuestaoTema>();

                    if (qteObjetiva > 0)
                    {
                        questoes.AddRange(Questao.ListarPorDisciplina(int.Parse(disciplina), temas, codDificuldade, TipoQuestao.OBJETIVA, qteObjetiva));
                    }

                    if (qteDiscursiva > 0)
                    {
                        questoes.AddRange(Questao.ListarPorDisciplina(int.Parse(disciplina), temas, codDificuldade, TipoQuestao.DISCURSIVA, qteDiscursiva));
                    }

                    foreach (var tema in temas)
                    {
                        var avalTema = new AvaliacaoTema();
                        avalTema.Tema = Tema.ListarPorCodigo(int.Parse(disciplina), int.Parse(tema));
                        foreach (var questaoTema in questoes.Where(q => q.CodTema == int.Parse(tema)))
                        {
                            var avalTemaQuestao = new AvalTemaQuestao();
                            avalTemaQuestao.QuestaoTema = questaoTema;
                            avalTema.AvalTemaQuestao.Add(avalTemaQuestao);
                        }
                        auto.Avaliacao.AvaliacaoTema.Add(avalTema);
                    }

                    auto.Avaliacao.DtCadastro = hoje;
                    auto.CodDificuldade       = dificuldades.Max();

                    AvalAuto.Inserir(auto);
                    Lembrete.AdicionarNotificacao($"Autoavaliação {auto.Avaliacao.CodAvaliacao} gerada com sucesso.", Lembrete.POSITIVO);
                    if (qteObjetiva + qteDiscursiva > auto.Avaliacao.Questao.Count)
                    {
                        Lembrete.AdicionarNotificacao("Autoavaliação de " + auto.Disciplina.First().Descricao + " gerada com quantidade de questões inferior ao requisitado", Lembrete.NEGATIVO, 0);
                    }
                }
                return(RedirectToAction("Realizar"));
            }
            else
            {
                var auto = new AvalAuto();

                DateTime hoje = DateTime.Now;

                /* Chave */
                auto.Avaliacao = new Avaliacao();
                auto.Avaliacao.TipoAvaliacao    = TipoAvaliacao.ListarPorCodigo(TipoAvaliacao.AUTOAVALIACAO);
                auto.Avaliacao.Ano              = hoje.Year;
                auto.Avaliacao.Semestre         = hoje.SemestreAtual();
                auto.Avaliacao.NumIdentificador = Avaliacao.ObterNumIdentificador(TipoAvaliacao.AUTOAVALIACAO);

                /* Pessoa */
                auto.CodPessoaFisica = Sistema.UsuarioAtivo[Sessao.UsuarioMatricula].Usuario.CodPessoaFisica;

                string[] disciplinas = formCollection["ddlDisciplinas"].Split(',');
                /* Dados */
                List <int> dificuldades               = new List <int>();
                int        quantidadeTotalObjetivas   = 0;
                int        quantidadeTotalDiscursivas = 0;
                foreach (var disciplina in disciplinas)
                {
                    /* Dificuldade */
                    int codDificuldade = int.Parse(formCollection["ddlDificuldade" + disciplina]);
                    dificuldades.Add(codDificuldade);

                    /* Quantidade */
                    int qteObjetiva   = 0;
                    int qteDiscursiva = 0;
                    if (formCollection["ddlTipo"] == "3")
                    {
                        int.TryParse(formCollection["txtQteObjetiva" + disciplina], out qteObjetiva);
                        int.TryParse(formCollection["txtQteDiscursiva" + disciplina], out qteDiscursiva);
                        quantidadeTotalObjetivas   += qteObjetiva;
                        quantidadeTotalDiscursivas += qteDiscursiva;
                    }
                    else if (formCollection["ddlTipo"] == "2")
                    {
                        int.TryParse(formCollection["txtQteDiscursiva" + disciplina], out qteDiscursiva);
                        quantidadeTotalDiscursivas += qteDiscursiva;
                    }
                    else if (formCollection["ddlTipo"] == "1")
                    {
                        int.TryParse(formCollection["txtQteObjetiva" + disciplina], out qteObjetiva);
                        quantidadeTotalObjetivas += qteObjetiva;
                    }

                    /* Temas */
                    string[] temas = formCollection["ddlTemas" + disciplina].Split(',');

                    /* Questões */
                    List <QuestaoTema> questoes = new List <QuestaoTema>();

                    if (qteObjetiva > 0)
                    {
                        questoes.AddRange(Questao.ListarPorDisciplina(int.Parse(disciplina), temas, codDificuldade, TipoQuestao.OBJETIVA, qteObjetiva));
                    }

                    if (qteDiscursiva > 0)
                    {
                        questoes.AddRange(Questao.ListarPorDisciplina(int.Parse(disciplina), temas, codDificuldade, TipoQuestao.DISCURSIVA, qteDiscursiva));
                    }

                    foreach (var tema in temas)
                    {
                        var avalTema = new AvaliacaoTema();
                        avalTema.Tema = Tema.ListarPorCodigo(int.Parse(disciplina), int.Parse(tema));
                        foreach (var questaoTema in questoes.Where(q => q.CodTema == int.Parse(tema)))
                        {
                            var avalTemaQuestao = new AvalTemaQuestao();
                            avalTemaQuestao.QuestaoTema = questaoTema;
                            avalTema.AvalTemaQuestao.Add(avalTemaQuestao);
                        }
                        auto.Avaliacao.AvaliacaoTema.Add(avalTema);
                    }
                }

                auto.Avaliacao.DtCadastro = hoje;
                auto.CodDificuldade       = dificuldades.Max();

                AvalAuto.Inserir(auto);
                Lembrete.AdicionarNotificacao($"Autoavaliação {auto.Avaliacao.CodAvaliacao} gerada com sucesso.", Lembrete.POSITIVO);
                if (quantidadeTotalDiscursivas + quantidadeTotalObjetivas > auto.Avaliacao.Questao.Count)
                {
                    Lembrete.AdicionarNotificacao("Autoavaliação gerada com quantidade de questões inferior ao requisitado", Lembrete.NEGATIVO, 0);
                }
                return(View(auto));
            }
        }
コード例 #6
0
        private async Task ValidaMinimoAvaliacoesBimestrais(DisciplinaDto disciplinaEOL, IEnumerable <DisciplinaResposta> disciplinasRegencia, long tipoCalendarioId, string turmaCodigo, int bimestre, TipoAvaliacao tipoAvaliacaoBimestral, NotasConceitosBimestreRetornoDto bimestreDto)
        {
            if (disciplinaEOL.Regencia)
            {
                var disciplinasObservacao = new List <string>();
                foreach (var disciplinaRegencia in disciplinasRegencia)
                {
                    var avaliacoes = await repositorioAtividadeAvaliativaRegencia.ObterAvaliacoesBimestrais(tipoCalendarioId, turmaCodigo, disciplinaRegencia.CodigoComponenteCurricular.ToString(), bimestre);

                    if ((avaliacoes == null) || (avaliacoes.Count() < tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre))
                    {
                        disciplinasObservacao.Add(disciplinaRegencia.Nome);
                    }
                }
                if (disciplinasObservacao.Count > 0)
                {
                    bimestreDto.Observacoes.Add($"A(s) disciplina(s) [{string.Join(",", disciplinasObservacao)}] não tem o número mínimo de avaliações bimestrais no bimestre {bimestre}");
                }
            }
            else
            {
                var avaliacoes = await repositorioAtividadeAvaliativaDisciplina.ObterAvaliacoesBimestrais(tipoCalendarioId, turmaCodigo, disciplinaEOL.CodigoComponenteCurricular.ToString(), bimestre);

                if ((avaliacoes == null) || (avaliacoes.Count() < tipoAvaliacaoBimestral.AvaliacoesNecessariasPorBimestre))
                {
                    bimestreDto.Observacoes.Add($"A disciplina [{disciplinaEOL.Nome}] não tem o número mínimo de avaliações bimestrais no bimestre {bimestre}");
                }
            }
        }
コード例 #7
0
        public string Gerar(string codigo, int[] justificaticoes, bool nova = false)
        {
            DateTime hoje = DateTime.Now;

            var           aval = new AvalAcadReposicao();
            AvalAcademica acad = AvalAcademica.ListarPorCodigoAvaliacao(codigo);

            aval.Avaliacao = new Avaliacao();

            aval.Avaliacao.TipoAvaliacao    = TipoAvaliacao.ListarPorCodigo(TipoAvaliacao.REPOSICAO);
            aval.Avaliacao.Ano              = hoje.Year;
            aval.Avaliacao.Semestre         = hoje.SemestreAtual();
            aval.Avaliacao.NumIdentificador = Avaliacao.ObterNumIdentificador(TipoAvaliacao.REPOSICAO);
            aval.Avaliacao.DtCadastro       = hoje;

            if (nova)
            {
                List <QuestaoTema>   lstQuestoes      = new List <QuestaoTema>();
                List <AvaliacaoTema> lstAvaliacaoTema = acad.Avaliacao.AvaliacaoTema.ToList();
                int      quantidadeObjetiva           = lstAvaliacaoTema.QteQuestoesPorTipo(TipoQuestao.OBJETIVA);
                int      quantidadeDiscursiva         = lstAvaliacaoTema.QteQuestoesPorTipo(TipoQuestao.DISCURSIVA);
                string[] temasCodigo    = lstAvaliacaoTema.Select(a => a.CodTema.ToString()).ToArray();
                int      codDificuldade = acad.Avaliacao.Questao.Max(a => a.CodDificuldade);

                if (quantidadeObjetiva > 0)
                {
                    lstQuestoes.AddRange(Questao.ListarPorDisciplina(acad.CodDisciplina, temasCodigo, codDificuldade, TipoQuestao.OBJETIVA, quantidadeObjetiva));
                }
                if (quantidadeDiscursiva > 0)
                {
                    lstQuestoes.AddRange(Questao.ListarPorDisciplina(acad.CodDisciplina, temasCodigo, codDificuldade, TipoQuestao.DISCURSIVA, quantidadeDiscursiva));
                }

                foreach (var temaCodigo in temasCodigo)
                {
                    var avalTema = new AvaliacaoTema();
                    avalTema.Tema = Tema.ListarPorCodigo(acad.CodDisciplina, int.Parse(temaCodigo));
                    foreach (var queTma in lstQuestoes.Where(q => q.CodTema == int.Parse(temaCodigo)))
                    {
                        var avalTemaQuestao = new AvalTemaQuestao();
                        avalTemaQuestao.QuestaoTema = queTma;
                        avalTema.AvalTemaQuestao.Add(avalTemaQuestao);
                    }
                    aval.Avaliacao.AvaliacaoTema.Add(avalTema);
                }
            }
            else
            {
                foreach (var avaliacaoTema in acad.Avaliacao.AvaliacaoTema)
                {
                    aval.Avaliacao.AvaliacaoTema.Add(new AvaliacaoTema
                    {
                        Tema            = avaliacaoTema.Tema,
                        AvalTemaQuestao = avaliacaoTema.AvalTemaQuestao.Select(a => new AvalTemaQuestao {
                            QuestaoTema = a.QuestaoTema
                        }).ToList()
                    });
                }
            }

            foreach (var codJustificacao in justificaticoes)
            {
                aval.Justificacao.Add(acad.Justificacoes.First(j => j.CodJustificacao == codJustificacao));
            }

            Repositorio.GetInstance().AvalAcadReposicao.Add(aval);
            Repositorio.Commit();

            return(nova ? Url.Action("Configurar", new { codigo = aval.Avaliacao.CodAvaliacao }) : Url.Action("Agendar", new { codigo = aval.Avaliacao.CodAvaliacao }));
        }
コード例 #8
0
 public void Cadastrar(TipoAvaliacao tipoAvaliacao)
 {
     throw new NotImplementedException();
 }
コード例 #9
0
        public ActionResult Confirmar(FormCollection formCollection)
        {
            var cert = new AvalCertificacao();

            if (formCollection.HasKeys())
            {
                DateTime hoje = DateTime.Now;

                /* Chave */
                cert.Avaliacao = new Avaliacao();
                cert.Avaliacao.TipoAvaliacao    = TipoAvaliacao.ListarPorCodigo(TipoAvaliacao.CERTIFICACAO);
                cert.Avaliacao.Ano              = hoje.Year;
                cert.Avaliacao.Semestre         = hoje.SemestreAtual();
                cert.Avaliacao.NumIdentificador = Avaliacao.ObterNumIdentificador(TipoAvaliacao.CERTIFICACAO);
                cert.Avaliacao.DtCadastro       = hoje;

                /* Professor */
                string matricula = Sessao.UsuarioMatricula;
                cert.Professor = Professor.ListarPorMatricula(matricula);

                /* Dados */
                int codDisciplina = int.Parse(formCollection["ddlDisciplina"]);

                cert.CodDisciplina = codDisciplina;

                /* Dificuldade */
                int codDificuldade = int.Parse(formCollection["ddlDificuldade"]);

                /* Quantidade */
                int quantidadeObjetiva   = 0;
                int quantidadeDiscursiva = 0;
                if (formCollection["ddlTipo"] == "3")
                {
                    int.TryParse(formCollection["txtQteObjetiva"], out quantidadeObjetiva);
                    int.TryParse(formCollection["txtQteDiscursiva"], out quantidadeDiscursiva);
                }
                else if (formCollection["ddlTipo"] == "2")
                {
                    int.TryParse(formCollection["txtQteDiscursiva"], out quantidadeDiscursiva);
                }
                else if (formCollection["ddlTipo"] == "1")
                {
                    int.TryParse(formCollection["txtQteObjetiva"], out quantidadeObjetiva);
                }

                /* Temas */
                string[] temasCodigo = formCollection["ddlTemas"].Split(',');

                /* Questões */
                List <QuestaoTema> lstQuestoes = new List <QuestaoTema>();

                if (quantidadeObjetiva > 0)
                {
                    lstQuestoes.AddRange(Questao.ListarPorDisciplina(codDisciplina, temasCodigo, codDificuldade, TipoQuestao.OBJETIVA, quantidadeObjetiva));
                }
                if (quantidadeDiscursiva > 0)
                {
                    lstQuestoes.AddRange(Questao.ListarPorDisciplina(codDisciplina, temasCodigo, codDificuldade, TipoQuestao.DISCURSIVA, quantidadeDiscursiva));
                }

                foreach (var temaCodigo in temasCodigo)
                {
                    var avalTema = new AvaliacaoTema();
                    avalTema.Tema = Tema.ListarPorCodigo(codDisciplina, int.Parse(temaCodigo));
                    foreach (var questaoTema in lstQuestoes.Where(q => q.CodTema == int.Parse(temaCodigo)))
                    {
                        var avalTemaQuestao = new AvalTemaQuestao();
                        avalTemaQuestao.QuestaoTema = questaoTema;
                        avalTema.AvalTemaQuestao.Add(avalTemaQuestao);
                    }
                    cert.Avaliacao.AvaliacaoTema.Add(avalTema);
                }

                AvalCertificacao.Inserir(cert);
            }

            return(RedirectToAction("Configurar", new { codigo = cert.Avaliacao.CodAvaliacao }));
        }