Beispiel #1
0
 private void contentsToolStripMenuItem_Click(object sender, EventArgs e)
 {
     Mensagem.ShowNaoImplementado(this);
 }
Beispiel #2
0
        public bool Validar()
        {
            bool ret = true;

            if (ret)
            {
                ret = IdDisciplina != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Disciplina não foi selecionada!");
                }
            }

            if (ret)
            {
                ret = TipoQuestao != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tipo da Questão não foi selecionado!");
                }
            }

            if (ret)
            {
                ret = Complexidade != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Complexidade não foi fornecida!");
                }
            }

            if (ret)
            {
                ret = Complexidade >= 1 && Complexidade <= 10;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Complexidade inválida! Utilize um número de 1 a 10!");
                }
            }

            if (ret)
            {
                ret = TempoResposta != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tempo de Resposta não fornecido!");
                }
            }

            if (ret)
            {
                ret = TempoResposta >= 1 && TempoResposta <= 360;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tempo de Resposta inválido! Utilize um número de 1 a 360 segundos!");
                }
            }

            if (ret)
            {
                ret = !Enunciado.Equals("");
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Enunciado não fornecido!");
                }
            }

            if (ret)
            {
                ret = QtdLinhasEnunciado != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Quantidade de linhas do Enunciado não foi fornecida!");
                }
            }

            if (ret)
            {
                ret = QtdLinhasEnunciado >= 1 && QtdLinhasEnunciado <= 20;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Quantidade de linhas do Enunciado inválida! Utilize um número de 1 a 20 linhas!");
                }
            }

            if (ret && TipoQuestao == TipoDeQuestao.Discursiva)
            {
                if (ret)
                {
                    ret = QtdLinhasResposta != 0;
                    if (!ret)
                    {
                        Mensagem.ShowAlerta(null, "Quantidade de linhas da resposta não foi fornecida!");
                    }
                }

                if (ret)
                {
                    ret = QtdLinhasResposta >= 1 && QtdLinhasResposta <= 20;
                    if (!ret)
                    {
                        Mensagem.ShowAlerta(null, "Quantidade de linhas da resposta inválida! Utilize um número de 1 a 20 linhas!");
                    }
                }
            }

            if (ret)
            {
                ret = TempoMinimoReutilizacao != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tempo mínimo de reutilização não fornecido!");
                }
            }

            if (ret)
            {
                ret = TempoMinimoReutilizacao >= 1 && TempoMinimoReutilizacao <= 9999;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tempo mínimo de reutilização inválido! Utilize um número de 0 e 9999 dias!");
                }
            }

            if (ret)
            {
                ret = TempoResposta != 0;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tempo de resposta não fornecido!");
                }
            }

            if (ret)
            {
                ret = TempoResposta >= 1 && TempoResposta <= 999;
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Tempo de resposta inválido! Utilize um número de 0 e 999 segundos!");
                }
            }

            if (ret)
            {
                ret = !SequenciaImpressao.Equals("");
                if (!ret)
                {
                    Mensagem.ShowAlerta(null, "Sequência de Impressão não foi fornecida!");
                }
            }

            if (ret)
            {
                ret = ValidaSequenciaImpressao(SequenciaImpressao);
            }

            return(ret);
        }
        private bool GravarAvaliacao()
        {
            bool ret = false;

            DBControl.BeginTrans();

            try
            {
                avaliacao = new Avaliacao();

                string codigo = GetCodigoAvaliacao();

                string strSeq = "";

                List <Avaliacao> avaliacoes = DBControl.Table <Avaliacao> .Pesquisar(x => x.Codigo.StartsWith(codigo));

                if (avaliacoes != null && avaliacoes.Count > 0)
                {
                    strSeq = avaliacoes[avaliacoes.Count - 1].Codigo.Substring(codigo.Length);
                }

                int seq = 1;

                if (!strSeq.Equals(""))
                {
                    seq = int.Parse(strSeq);
                    seq++;
                }

                codigo = codigo + seq.ToString("000");

                StringBuilder sb = new StringBuilder();

                sb.Append("Avaliação ");
                sb.Append(tipoAvaliacao);
                sb.Append(" ");
                sb.Append(disciplina.Nome);
                sb.Append(" sequência ");
                sb.Append(seq.ToString("000"));

                avaliacao.Codigo       = codigo;
                avaliacao.Descricao    = sb.ToString();
                avaliacao.DtGeracao    = dtGeracao;
                avaliacao.IdDisciplina = parametersGA.IdDisciplina;
                avaliacao.QtdQuestoes  = parametersGA.QtdQuestoes;

                int idAvaliacao = DBControl.Table <Avaliacao> .Incluir(avaliacao);

                ret = idAvaliacao > 0;

                if (ret)
                {
                    AvaliacaoQuestao aq;
                    int id;

                    foreach (int idQuestao in questoes)
                    {
                        aq = new AvaliacaoQuestao();

                        aq.IdAvaliacao = idAvaliacao;
                        aq.DtGeracao   = dtGeracao;
                        aq.IdQuestao   = idQuestao;

                        id = DBControl.Table <AvaliacaoQuestao> .Incluir(aq);

                        ret = id > 0;

                        if (!ret)
                        {
                            break;
                        }
                    }
                }

                if (ret)
                {
                    DBControl.Commit();
                }
                else
                {
                    DBControl.Rollback();
                }
            }
            catch (Exception ex)
            {
                Mensagem.ShowErro("Erro na inclusão da Avaliação!", ex);
                DBControl.Rollback();
            }

            return(ret);
        }
Beispiel #4
0
        private bool ValidarParametrizacao()
        {
            bool ret = true;

            /*
             * if (ret)
             * {
             *  ret = colControlComplexidade.HasConfiguratedRules > 0;
             *
             *  if (!ret)
             *      Mensagem.ShowAlerta(this,"Não existem regras definidas na configuração de complexidades!");
             * }
             */
            if (ret)
            {
                ret = colControlComplexidade.IsAllValid;

                if (!ret)
                {
                    int index = colControlComplexidade.FirstInvalid;

                    Mensagem.ShowAlerta(this, "Regra " + (index + 1).ToString() + " da configuração de complexidades está inconsistênte ou incompleta!");
                }
            }

            /*
             * if (ret)
             * {
             *  ret = colControlTipoQuestao.HasConfiguratedRules > 0;
             *
             *  if (!ret)
             *      Mensagem.ShowAlerta(this,"Não existem regras definidas na configuração de tipos de questões!");
             * }
             */
            if (ret)
            {
                ret = colControlTipoQuestao.IsAllValid;

                if (!ret)
                {
                    int index = colControlTipoQuestao.FirstInvalid;

                    Mensagem.ShowAlerta(this, "Tipo de questão [" + colControlTipoQuestao[index].TipoQuestao.ToString() + "] da configuração de tipos de questão está inconsistênte!");
                }
            }

            if (ret && colControlTipoQuestao.HasConfiguratedRules > 0)
            {
                ConfigTipoQuestao[] list = colControlTipoQuestao.GetValidConfigTipoQuestao();

                int qtdTotal = 0;

                foreach (ConfigTipoQuestao conf in list)
                {
                    qtdTotal += conf.Quantidade;
                }

                ret = qtdTotal <= numQtdQuestoes.Value;

                if (!ret)
                {
                    Mensagem.ShowAlerta(this, "A soma das quantidades selecionadas na configuração de tipos de questão é maior que a quantidade de questões para a avaliação!");
                }

                if (ret)
                {
                    ret = list.Length < 4 || (list.Length == 4 && qtdTotal == numQtdQuestoes.Value);

                    if (!ret)
                    {
                        Mensagem.ShowAlerta(this, "A configuração de tipos de questão não permite solução!");
                    }
                }
            }

            if (ret)
            {
                ret = !cboTipoAvaliacao.Text.Trim().Equals("");

                if (!ret)
                {
                    Mensagem.ShowAlerta(this, "Tipo de Avaliação não foi selecionado!");
                }
            }

            return(ret);
        }