/// <summary>
/// Cria uma resposta simulada do candidato
/// </summary>
/// <param name="elaborador"></param>
/// <param name="questao"></param>
/// <param name="candidato"></param>
/// <param name="img"></param>
/// <returns></returns>
private static Resposta MontarResposta(Usuario elaborador, Questao questao, Candidato candidato, Image img)
{
var resposta = new Resposta
{
QuestaoID = questao.QuestaoID,
Questao = questao,
/*dados para candidato*/
CandidatoID = candidato.CandidatoID,
Candidato = candidato,
/*dados do elaborador*/
UsuarioID = elaborador.UsuarioID,
Usuario = elaborador,
/*folha de redação*/
RespostaImagem = Util.ConverterParaArray(img),
//por falta de tempo vamos deixar a grade fixa "1" o ideal é ser outra tabela
RespostaGradeEscolhida = 1,
/*o professor é quem dará a nota*/
RespostaNota = 0,
RespostaNotaConcluida = false
};
return(resposta);
}
public Questao Make(IDataReader reader)
{
Questao questao = new Questao();
questao.ID = Convert.ToInt32(reader["QuestaoID"]);
questao.Bimestre = Convert.ToString(reader["QuestaoBimestre"]);
questao.Pergunta = Convert.ToString(reader["Questao"]);
questao.materia = new Materia
{
ID = Convert.ToInt32(reader["QuestaoMateriaID"]),
Nome = Convert.ToString(reader["MateriaNome"]),
disciplina = new Disciplina
{
ID = Convert.ToInt32(reader["MateriaDisciplinaID"]),
Nome = Convert.ToString(reader["DisciplinaNome"]),
},
serie = new Serie
{
ID = Convert.ToInt32(reader["MateriaSerieID"]),
Nome = Convert.ToString(reader["SerieNome"])
}
};
questao.Alternativa = new Alternativas
{
ID = Convert.ToInt32(reader["AlternativaID"]),
A = Convert.ToString(reader["A"]),
B = Convert.ToString(reader["B"]),
C = Convert.ToString(reader["C"]),
D = Convert.ToString(reader["D"]),
Correta = Convert.ToString(reader["AlternativaCorreta"])
};
return(questao);
}
public async Task <IActionResult> Update([FromRoute] int QuestaoId, [FromBody] Questao questao)
{
questao.QuestaoId = QuestaoId;
await _questoesRepository.Update(questao);
return(Ok());
}
public ActionResult CadastrarDT(Questao questao, string AssuntoQuestao, string DisciplinaId)
{
if (questao.Enunciado == null || questao.Enunciado.Equals(""))
{
TempData["$AlertMessage$"] = "Favor prencher o enunciado da questão!";
return(RedirectToAction("CadastrarQuestoes", "CadastrarQuestoes"));
}
if (questao.RespostaDiscursiva == null || questao.RespostaDiscursiva.Equals(""))
{
TempData["$AlertMessage$"] = "Favor prencher a resposta da questão!";
return(RedirectToAction("CadastrarQuestoes", "CadastrarQuestoes"));
}
questao.TipoQuestao = 4;
questao.situacao = 1;
var x = DisciplinaDAO.BuscarDisciplinaId(Convert.ToInt32(DisciplinaId));
questao.Disciplina = x;
var y = QuestaoDAO.BuscarAssuntoId(Convert.ToInt32(AssuntoQuestao));
questao.AssuntoQuestao = y;
QuestaoDAO.CadastrarQuestao(questao);
TempData["$AlertMessage$"] = "Questão Criada com Sucesso";
return(RedirectToAction("CadastrarQuestoes", "CadastrarQuestoes"));
}
private void AtualizarListaDeQuestoes(Licao licao, IEnumerable <QuestaoDTO> questoesParaSalvar)
{
foreach (var questaoDTO in questoesParaSalvar)
{
Questao questao = licao.Questoes.FirstOrDefault(q => q.Id == questaoDTO.Id);
if (questao == null)
{
questao = new Questao
{
IdLicao = licao.Id,
// Licao = licao
};
licao.Questoes.Add(questao);
}
questaoDTO.PreencherEntidade(questao);
}
List <Questao> questoesRemovidas = licao.Questoes.Where(qe => qe.Id > 0 && !questoesParaSalvar.Any(qs => qs.Id == qe.Id)).ToList();
foreach (var questaoRemovida in questoesRemovidas)
{
licao.Questoes.Remove(questaoRemovida);
}
}
private void LoadQuestoesFromDevice(int numDisciplina, int numAtividade)
{
FileStream stream = null;
bool hasQuestions = true;
int numQuestao = 0;
while (hasQuestions)
{
string path = "/questoes/quest-" + numDisciplina + "-" + numAtividade + "-" + numQuestao;
if (FileExists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
stream = GetStream(path);
Questao questao = formatter.Deserialize(stream) as Questao;
disciplinasDefault[numDisciplina].atividades[numAtividade].questoes.Add(questao);
LoadConteudoFromDevice(numDisciplina, numAtividade, numQuestao);
numQuestao++;
}
else
{
hasQuestions = false;
}
}
loadScreen.SetActive(false);
}
public async Task <IActionResult> PutQuestao([FromRoute] int id, [FromBody] Questao questao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != questao.Id)
{
return(BadRequest());
}
_context.Entry(questao).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void btnSalvar_Click_1(object sender, EventArgs e)
{
try
{
lbStatus.Text = string.Empty;
if (_questao == null)
{
_questao = new Questao();
}
_questao.Pergunta = txtPergunta.Text;
_questao.Materia = cbxMateria.SelectedItem as Materia;
_questao.Bimestre = (Bimestre)cbxBimestre.SelectedValue;
_questao.Validar();
_service.ValidaDuplicado(_questao);
btnSalvar.Enabled = true;
ValidaCorreta();
}
catch (Exception ex)
{
DialogResult = DialogResult.None;
lbStatus.ForeColor = Color.Red;
lbStatus.Text = ex.Message;
}
}
public Questao Consultar(int id)
{
SqlCommand comm = new SqlCommand("Select * from Questao Where ID_Questao = " + id, Banco.Abrir());
SqlDataReader dr = comm.ExecuteReader();
Questao q = new Questao();
while (dr.Read())
{
q.ID = Convert.ToInt32(dr.GetValue(0));
Exercicio e = new Exercicio();
e.ID = Convert.ToInt32(dr.GetValue(1));
q.Exercicio = e;
q.Ordem = Convert.ToInt32(dr.GetValue(2));
q.AleatorioAlternativa = Convert.ToBoolean(dr.GetValue(3));
q.Pergunta = dr.GetValue(4).ToString();
q.Usuario = Convert.ToInt32(dr.GetValue(5));
}
dr.Close();
comm.CommandText = "Select ID_Alternativa, Ordem_Alternativa from Alternativa Where ID_Questao = " + id + " order by Ordem_Alternativa";
dr = comm.ExecuteReader();
List <Alternativa> lista = new List <Alternativa>();
while (dr.Read())
{
AlternativaDAL dalalter = new AlternativaDAL();
Alternativa a = new Alternativa();
a = dalalter.Consultar(Convert.ToInt32(dr.GetValue(0)));
lista.Add(a);
}
q.Alternativa = lista;
comm.Connection.Close();
return(q);
}
public override void Editar()
{
try
{
Questao materiaSelecionada = _controlQuestao.ObtemQuestaoSelecionada();
FormQuestao form = new FormQuestao(_serviceQuestao, _serviceMateria);
form.EditarQuestao = materiaSelecionada;
DialogResult result = form.ShowDialog();
if (result == DialogResult.OK)
{
_serviceQuestao.Editar(form.EditarQuestao);
}
List <Questao> questoes = _serviceQuestao.PegarTodos();
_controlQuestao.PopularListagemQuestoes(questoes);
}
catch (NullReferenceException)
{
throw new Exception("Selecione uma questão");
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public object Criar(string titulo, int tipoQuestao, int idQuestionario)
{
using (var context = new Context())
{
var questionario = context.DbQuestionarios.Where(q => q.IdQuestionario.Equals(idQuestionario)).FirstOrDefault();
var tipoQuestaoEnum = (TipoQuestao)tipoQuestao;
var questao = new Questao
{
Titulo = titulo,
Tipo = tipoQuestaoEnum,
Questionario = questionario,
IdQuestionario = idQuestionario
};
context.Set <Questao>().Add(questao);
context.SaveChanges();
var anonObj = new
{
uid = questao.IdQuestao,
titulo = questao.Titulo,
tipo = questao.Tipo.ToString()
};
var serializer = new JavaScriptSerializer();
return(serializer.Serialize(anonObj));
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AvaliacaoId,Tipo,Enunciado")] Questao questao)
{
if (id != questao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(questao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestaoExists(questao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AvaliacaoId"] = new SelectList(_context.Avaliacoes, "Id", "Id", questao.AvaliacaoId);
return(View(questao));
}
public void DadoDesricaoInvalida_QuandoCriarQuestaoDissertativa_DevoReceberFalha()
{
var questao = Questao.CriarDissertativa(_nivelEnsino, _disciplina, "");
questao.IsFailure.ShouldBeTrue();
questao.Error.ShouldBe(QuestoesMotivosErro.DescricaoObrigatoria);
}
public void DeveTerPeloMenosDuasAlternativas()
{
try
{
Questao questao = new Questao()
{
Pergunta = "Quanto é 100 + 1 ?"
};
Alternativa alternativa = new Alternativa()
{
Descricao = "lalalalalalalaaaaaaa"
};
Materia materia = new Materia()
{
Nome = "Matemática"
};
questao.Alternativas.Add(alternativa);
questao.Materia = materia;
questao.Validar();
}
catch (Exception ex)
{
Assert.AreEqual(ex.Message, "Cadastre pelo menos duas alternativas!");
return;
}
Assert.Fail();
}
public async Task <IActionResult> Edit(int id, [Bind("QuestaoID,NomeQuestao,Desactivada,Descricao")] Questao questao)
{
if (id != questao.QuestaoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(questao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestaoExists(questao.QuestaoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(questao));
}
public async Task <IActionResult> DetalharQuestao(int Id)
{
Questao questao = await _questaoService.GetQuestaoPorId(Id);
EditarQuestaoViewModel editarQuestaoViewModel = new EditarQuestaoViewModel
{
Cabecalho = questao.Cabecalho,
IdQuestao = questao.Id,
Opcoes = questao.ListaOpcao,
Texto = questao.Texto
};
int indiceOpcao = 0;
foreach (Opcao opcao in questao.ListaOpcao)
{
Opcao_Correta opcao_Correta = await _opcao_Correta.GetOpcaoCorreta(opcao.Id);
if (opcao_Correta != null)
{
editarQuestaoViewModel.Selecionado = indiceOpcao.ToString();
break;
}
indiceOpcao++;
}
return(View(editarQuestaoViewModel));
}
public void MetodoToStringQuestaoMais30Caracteres()
{
Questao questao = new Questao()
{
Pergunta = "wafaewfaevewvvewvewwwwwwwwwwwwaaawed2rfc3rt5g4y6gfedwrd4y6"
};
Materia materia = new Materia()
{
Nome = "Matemática"
};
materia.Serie = new Serie()
{
Nome = "1"
};
materia.Disciplina = new Disciplina()
{
Nome = "Aritmética"
};
questao.Materia = materia;
questao.Bimestre = Enum.Bimestre.Primeiro;
Assert.AreEqual(questao.ToString(), "Questão: wafaewfaevewvvewvewwwwwwwwwwww..., Matéria: Matemática, Série: 1, Disciplina: Aritmética");
}
public async Task <IActionResult> EditarQuestao(EditarQuestaoViewModel model)
{
if (ModelState.IsValid)
{
int opcaoCorreta = model.Selecionado != null?int.Parse(model.Selecionado) : -1;
Questao questao = await _questaoService.GetQuestaoPorId(model.IdQuestao);
int indiceOpcao = 0;
foreach (Opcao opcao in questao.ListaOpcao)
{
Opcao_Correta opcao_Correta = await _opcao_Correta.GetOpcaoCorreta(opcao.Id);
if (opcao_Correta != null)
{
if (indiceOpcao.ToString() != model.Selecionado)
{
opcao_Correta.IdOpcao = model.Opcoes[opcaoCorreta].Id;
await _opcao_Correta.UpdateOpcao_CorretaAsync(opcao_Correta);
break;
}
}
indiceOpcao++;
await _opcao.UpdateOpcaoAsync(opcao);
}
questao.Cabecalho = model.Cabecalho;
questao.Texto = model.Texto;
await _questaoService.UpdateQuestaoAsync(questao);
}
return(View());
}
public void SalvarResposta(string codigo, int questao, string resposta, string comentario) =>
AvalQuesPessoaResposta.SalvarResposta(
Avaliacao.ListarPorCodigoAvaliacao(codigo),
Questao.ListarPorCodigo(questao),
Sistema.UsuarioAtivo[Sessao.UsuarioMatricula].Usuario.PessoaFisica,
resposta,
comentario);
static void Main(string[] args)
{
var partidaFactory = new PartidaFactory();
var treino = partidaFactory.GetPartida(TipoPartidaCode.Treino);
var usuarioFactory = new UsuarioFactory();
var monitor = usuarioFactory.GetUsuario(TipoUsuarioCode.Monitor);
var administrador = usuarioFactory.GetUsuario(TipoUsuarioCode.Administrador);
var jogadorUsuario = usuarioFactory.GetUsuario(TipoUsuarioCode.Jogador);
var jogadorUsuario2 = usuarioFactory.GetUsuario(TipoUsuarioCode.Jogador);
monitor.Hello();
administrador.Hello();
jogadorUsuario.Hello();
Console.WriteLine();
var jogador = (Jogador)jogadorUsuario;
jogador.Id = 2;
var jogador2 = (Jogador)jogadorUsuario2;
((Partida)treino).RegistrarJogador(jogador);
((Partida)treino).RegistrarJogador(jogador2);
_ = jogador.Ação(jogador.Id);
Console.WriteLine("\n");
var questao = new Questao();
questao.Attach((Monitor)monitor);
questao.SomeBusinessLogic();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Pergunta,Opcao_a,Opcao_b,Opcao_c,Opcao_d,Resposta_certa")] Questao questao)
{
if (id != questao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(questao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestaoExists(questao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(questao));
}
public async Task <IActionResult> Edit(int id, [Bind("Id, TextoPergunta, Resposta, HtmlPergunta, ExercicioId")] Questao questao)
{
if (id != questao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
questao.DataHoraModificacao = DateTime.Now;
_context.Update(questao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestaoExists(questao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
var exercicios = from t in _context.Exercicios
select t;
ViewData["Exercicios"] = new SelectList(exercicios.ToList(), "Id", "Descricao");
return(View(questao));
}
/// <summary>
/// Retorna um objeto do tipo exercicio completo com list de questoes (ordenadas ) ja com alternativas (ordenadas)
/// </summary>
/// <param name="id">parametro inteiro representando o ID do exercicio</param>
/// <returns></returns>
public Exercicio Consultar(int id)
{
SqlCommand comm = new SqlCommand("Select * from Exercicio Where ID_Exercicio = " + id, Banco.Abrir());
SqlDataReader dr = comm.ExecuteReader();
Exercicio e = new Exercicio();
while (dr.Read())
{
e.ID = Convert.ToInt32(dr.GetValue(0));
Conteudo cont = new Conteudo();
cont.ID = Convert.ToInt32(dr.GetValue(1));
e.Conteudo = cont;
e.Descricao = dr.GetValue(2).ToString();
e.Tipo = dr.GetValue(3).ToString();
e.AleatorioQuestao = Convert.ToBoolean(dr.GetValue(4));
e.Usuario = Convert.ToInt32(dr.GetValue(5));
}
dr.Close();
comm.CommandText = "Select ID_Questao, Ordem_Questao from Questao Where ID_Exercicio = " + id + " order by Ordem_Questao";
dr = comm.ExecuteReader();
List <Questao> lista = new List <Questao>();
while (dr.Read())
{
QuestaoDAL dalq = new QuestaoDAL();
Questao q = new Questao();
q = dalq.Consultar(Convert.ToInt32(dr.GetValue(0)));
lista.Add(q);
}
e.Questao = lista;
comm.Connection.Close();
return(e);
}
private void btnGerarTeste_Click(object sender, EventArgs e)
{
var materia = new Materia();
var questao = new Questao();
var teste = new Teste();
try
{
VerificaCampos();
materia.Nome = cmbMateria.SelectedItem.ToString();
questao.Bimestre = cmbBimestre.SelectedItem.ToString();
teste.QuantidadeQuestoes = Convert.ToInt32(quantidadeQuestoes.Value);
teste.dataGeracao = DateTime.Now;
teste.Descricao = "Descrição";
teste.listaQuestao = _questoesServico.GetAllRandom(teste, materia, questao);
_testeServico.GerarTeste(teste, materia, questao);
MessageBox.Show("Adicionado com sucesso", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Information);
DialogResult = DialogResult.OK;
}
catch (Exception ex)
{
DialogResult = DialogResult.None;
MessageBox.Show(ex.Message, "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void DadoNivelDeEnsinoInvalido_QuandoCriarQuestaoDissertativa_DevoReceberFalha()
{
var questao = Questao.CriarDissertativa(0, 123, _descricao);
questao.IsFailure.ShouldBeTrue();
questao.Error.ShouldBe(QuestoesMotivosErro.NivelEnsinoObrigatorio);
}
private void CarregarQuestao(QuestionarioConstrutor questionarioConstrutor, Questao questao)
{
this.questaoParaAlterar = new Questao();
this.questaoParaAlterar = questao;
this.questao = questao;
this.questionarioConstrutor = questionarioConstrutor;
}
private void carregarQuestoes(int codigoProblema)
{
//mostra todas as questões do problema
Table table = new Table();
table.CssClass = "invisible";
TableHeaderRow hr = new TableHeaderRow();
TableHeaderCell hc1 = new TableHeaderCell();
TableHeaderCell hc2 = new TableHeaderCell();
hc1.Text = "Questão";
hc2.Text = "Resposta";
hr.Controls.Add(hc1);
hr.Controls.Add(hc2);
table.Controls.Add(hr);
List <Questao> questoes = Questao.carregaQuestoes(codigoProblema);
foreach (Questao q in questoes)
{
TableRow row = new TableRow();
TableCell cellQuestao = new TableCell();
TableCell cellResposta = new TableCell();
cellQuestao.Text = q.questao;
cellResposta.Text = q.resposta.ToString();
row.Controls.Add(cellQuestao);
row.Controls.Add(cellResposta);
table.Controls.Add(row);
table.CssClass = "superFancyTable";
}
panelQuestoes.Controls.Add(table);
}
private void btnAddAlternativa_Click(object sender, EventArgs e)
{
lbStatus.Text = string.Empty;
try
{
if (_questao == null)
{
_questao = new Questao();
}
_questao.ValidaExistenciaAlternativa(txtAlternativa.Text);
_alternativa = new Alternativa();
_alternativa.Descricao = txtAlternativa.Text;
_alternativa.Validar();
_questao.Alternativas.Add(_alternativa);
populateListBox();
PopulateComboBoxAlternativaCorreta();
ValidaAddAlternativa();
txtAlternativa.Text = string.Empty;
}
catch (Exception ex)
{
DialogResult = DialogResult.None;
lbStatus.ForeColor = Color.Red;
lbStatus.Text = ex.Message;
}
}
public override void Remover()
{
try
{
Questao questaoSelecionada = _controlQuestao.ObtemQuestaoSelecionada();
DialogResult resultado = MessageBox.Show(
"Tem certeza que deseja excluir a questão?" + questaoSelecionada.ToString(),
"Excluir questão?",
MessageBoxButtons.OKCancel, MessageBoxIcon.Question);
if (resultado == DialogResult.OK)
{
_serviceQuestao.Excluir(questaoSelecionada);
List <Questao> questoes = _serviceQuestao.PegarTodos();
_controlQuestao.PopularListagemQuestoes(questoes);
}
}
catch (NullReferenceException)
{
throw new Exception("Selecione uma Questão!");
}
catch (Exception)
{
throw new Exception("Não é possível excluir, Questão possui registros vinculados!");
}
}
public async Task <Questao> Post(int tarefaId, [FromBody] QuestaoCadastroViewModel model)
{
var tarefa = await db.Tarefas
.Include(d => d.Questoes)
.FirstOrDefaultAsync(d => d.Id == tarefaId);
if (tarefa == null)
{
throw new HttpException(404);
}
var questao = new Questao()
{
Conteudo = model.Conteudo,
Ordem = model.Ordem,
Titulo = model.Titulo,
Tarefa = tarefa
};
tarefa.Questoes.Add(questao);
await db.SaveChangesAsync();
return(questao);
}
public static Boolean cadastrarQuestao(int idAvaliacao, string questao)
{
Questao qt = new Questao();
qt.idAvaliacao = idAvaliacao;
qt.questao = questao;
return qt.cadastrar();
}
protected Boolean cadastrar(Questao questao)
{
var sql = "INSERT INTO `questao`(`idbasico`, `idavaliacao`, `questao`) VALUES (@idbasico, @idavaliacao, @questao)";
var parametros = new List<MySqlParameter>();
parametros.Add(new MySqlParameter("@idbasico", questao.basico.cadastraReturnId()));
parametros.Add(new MySqlParameter("@idavaliacao", questao.idAvaliacao));
parametros.Add(new MySqlParameter("@questao", questao.questao));
return base.comandoSQL(sql, parametros);
}
public IActionResult Create(Questao questao)
{
if (ModelState.IsValid)
{
questao.Id = Guid.NewGuid();
db.Set<Questao>().Add(questao);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(questao);
}
public IActionResult Edit(Questao questao)
{
if (ModelState.IsValid)
{
db.Update(questao);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(questao);
}
