public static Boolean cadastrar(string titulo)
{
Avaliacao avaliacao = new Avaliacao();
avaliacao.titulo = titulo;
return avaliacao.cadastrar();
}
protected Boolean cadastrar(Avaliacao avaliacao)
{
var sql = "INSERT INTO `avaliacao`(`idbasico`, `titulo`) VALUES (@idbasico, @titulo)";
var parametros = new List<MySqlParameter>();
parametros.Add(new MySqlParameter("@idbasico", avaliacao.basico.cadastraReturnId()));
parametros.Add(new MySqlParameter("@titulo", avaliacao.titulo));
return base.comandoSQL(sql, parametros);
}
/// <summary>
/// Retorna um objeto do tipo Avaliacao com a Avaliação de 1 usuario em especifico sendo, de uma resposta ou pergunta
/// Com Pergunta, Usuario e Resposta sendo nulo ou so o ID
/// Se o ID da Pergunta for 0 então retorna a avaliação da resposta
/// Se o ID_Resposta for 0 então retorna a avaliação da pergunta
/// </summary>
/// <param name="usuario">Recebe um inteiro do ID do Usuario</param>
/// <param name="pergunta">Recebe um inteiro do ID do Pergunta</param>
/// <param name="resposta">Recebe um inteiro do ID da Resposta</param>
/// <returns></returns>
public Avaliacao Consultar(int usuario, int pergunta, int resposta)
{
SqlCommand comm = new SqlCommand("", Banco.Abrir());
if (pergunta > 0)
{
comm.CommandText = "Select * from AvaliacaoPergunta where ID_Usuario = " + usuario + " and ID_Pergunta = " + pergunta;
}
else
{
comm.CommandText = "Select * from AvaliacaoResposta where ID_Usuario = " + usuario + " and ID_Resposta = " + resposta;
}
SqlDataReader dr = comm.ExecuteReader();
Avaliacao a = new Avaliacao();
while (dr.Read())
{
a.ID = Convert.ToInt32(dr.GetValue(0));
Usuario u = new Usuario();
u.ID = Convert.ToInt32(dr.GetValue(1));
a.Usuario = u;
if (pergunta > 0)
{
Pergunta p = new Pergunta();
p.ID = Convert.ToInt32(dr.GetValue(2));
a.Pergunta = p;
a.Resposta = null;
}
else
{
Resposta r = new Resposta();
r.ID = Convert.ToInt32(dr.GetValue(2));
a.Pergunta = null;
a.Resposta = r;
}
if (Convert.ToBoolean(dr.GetValue(4)) == false)
{
a._Avaliacao = Convert.ToBoolean(dr.GetValue(3));
a.Denuncia = false;
}
else
{
a.Denuncia = true;
}
}
comm.Connection.Close();
return(a);
}
public bool Incluir(Avaliacao avaliaco)
{
try
{
using (var context = new glassDbEntities())
{
context.tb_avaliacao.Add(avaliaco);
context.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
}
// GET: Avaliacoes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Avaliacao avaliacao = db.Avaliacao.Find(id);
if (avaliacao == null)
{
return(HttpNotFound());
}
ViewBag.Clientes = new SelectList(db.Cliente, "id", "nome", avaliacao.clienteId);
this.ConfiguraNomeCliente(avaliacao);
return(View(avaliacao));
}
public bool Alterar(Avaliacao avaliacao)
{
Avaliacao avaliacaoOriginal = context.Avaliacaos.FirstOrDefault(x => x.Id == avaliacao.Id);
if (avaliacaoOriginal == null)
{
return(false);
}
avaliacaoOriginal.FeedBack = avaliacao.FeedBack;
avaliacaoOriginal.Nota = avaliacao.Nota;
avaliacaoOriginal.Comentario = avaliacao.Comentario;
avaliacaoOriginal.Cliente = avaliacao.Cliente;
context.SaveChanges();
return(true);
}
// GET: Avaliacoes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Avaliacao avaliacao = db.Avaliacao.Find(id);
if (avaliacao == null)
{
return(HttpNotFound());
}
ViewBag.ProdutoId = new SelectList(db.Produto, "ID", "Nome", avaliacao.ProdutoId);
ViewBag.UtilizadorId = new SelectList(db.Utilizador, "ID", "Username", avaliacao.UtilizadorId);
return(View(avaliacao));
}
// POST: api/Avaliacao
public void Post([FromBody][Bind(Include = "Id,Id_Treinamento,Cod_Modulo,Descricao")] Avaliacao avaliacao)
{
if (ModelState.IsValid)
{
if (avaliacao.Id == 0)
{
db.Avaliacoes.Add(avaliacao);
db.SaveChanges();
}
else
{
db.Entry(avaliacao).State = EntityState.Modified;
db.SaveChanges();
}
}
}
private ActionResult GravarAvaliacao(Avaliacao avaliacao)
{
try
{
if (ModelState.IsValid)
{
avaliacaoServico.GravarAvaliacao(avaliacao);
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index"));
}
catch
{
return(View(avaliacao));
}
}
// métodos para alteração no banco
public static void AlterarAvaliacao(Avaliacao a)
{
List <object> param = new List <object>();
param = a.GetList(false);
int i = 1;
string sql = "UPDATE public.avaliacao " +
"SET id_instrumento = @" + (i++) + ", id_relatorio = @" + (i++) + " " +
"WHERE id_avaliacao = " + a.Id_Avaliacao;
Connection.Open();
Connection.Run(sql, param);
Connection.Close();
}
public async Task <IActionResult> Create([Bind("Materia,Descricao,IdDisciplina")] Avaliacao avaliacao)
{
if (ModelState.IsValid)
{
var professor = await _professorService.BuscarPorEmail(LoginUsuario.Email);
avaliacao.IdProfessor = professor.Id;
int id_avaliacao = await _avaliacaoService.AdicionarAvaliacaoAsync(avaliacao.Materia, avaliacao.Descricao, avaliacao.IdProfessor, avaliacao.IdDisciplina);
return(RedirectToAction(nameof(Edit), new { id = id_avaliacao }));
}
ViewData["IdDisciplina"] = new SelectList(await _disciplinaRepository.ListarTodosAsync(), "Id", "Nome", avaliacao.IdDisciplina);
return(View(avaliacao));
}
public bool InserirAvaliacao(Avaliacao avaliacao)
{
try
{
bool verificacao = Dao.AlterarAvaliacao(avaliacao);
avaliacao.Nota = CalcularNota(avaliacao);
avaliacao.DtAvaliacao = DateTime.Now;
bool inserido = Dao.InserirAvaliacao(avaliacao);
return(inserido);
}
catch (Exception ex)
{
throw ex;
}
}
public void TestaAvaliacaoSemNota()
{
var avalicaoService = new AvaliacaoService();
var musica = new Musica("nome", 20);
var usuario = new Usuario("usuario show");
Avaliacao avaliacao = new Avaliacao(musica, usuario, 55);
var erros = avalicaoService.Validar(avaliacao);
CollectionAssert.AreEqual(new List <string> {
"Nota que precisa estar entre 0 e 5"
}, erros);
}
public Avaliacao Edit(Avaliacao entity, int key)
{
if (entity == null)
{
return(null);
}
Avaliacao existing = DataContext.Set <Avaliacao>().Find(key);
if (existing != null)
{
DataContext.Entry(existing).CurrentValues.SetValues(entity);
DataContext.SaveChanges();
}
return(existing);
}
public async Task <IActionResult> Create([Bind("Id,ModuloId,Descricao")] Avaliacao avaliacao)
{
if (ModelState.IsValid)
{
_context.Add(avaliacao);
await _context.SaveChangesAsync();
var modulo = await _context.Modulos.FindAsync(avaliacao.ModuloId);
modulo.AvaliacaoId = avaliacao.Id;
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(avaliacao));
}
public void mustSearchSomeFeatures()
{
mustSaveAModel();
Avaliacao _Avaliacao = new Avaliacao(_workspace);
var _Avaliacoes = _Avaliacao.Search("Avaliacao.Codigo = 1");
foreach (Avaliacao _item in _Avaliacoes)
{
Assert.AreEqual(_item.Comentario, "Relativamente bom!");
Assert.AreEqual(_item.Nome, "Teste");
}
Assert.IsTrue(_Avaliacoes.Count > 0);
_Avaliacao.Load(1);
_Avaliacao.Delete();
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Avaliacao = await _context.Avaliacao
.Include(a => a.Disciplina).FirstOrDefaultAsync(m => m.Id == id);
if (Avaliacao == null)
{
return(NotFound());
}
return(Page());
}
// GET: Avaliacao
public ActionResult Index()
{
if (Session["usuario"] == null || Session["usuario"].ToString() == "")
{
return(RedirectToAction("Login", "Home").Mensagem("Faça o login para entrar"));
}
Avaliacao avaliacao = new Avaliacao();
IEnumerable <Avaliacao> lista = avaliacao.listaAvaliacao();
if (avaliacao.erro != "")
{
return(View(lista).Mensagem(avaliacao.erro));
}
return(View(lista));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Disciplina,Materia,Descricao")] Avaliacao avaliacao)
{
if (id != avaliacao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _avaliacaoService.AlterarAvaliacaoAsync(avaliacao.Id, avaliacao.Disciplina, avaliacao.Materia, avaliacao.Descricao);
return(RedirectToAction(nameof(Index)));
}
return(View(avaliacao));
}
// GET: Avaliacaos/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Avaliacao avaliacao = db.Avaliacaos.Find(id);
db.Entry(avaliacao).Reference(p => p.Atleta).Load();
db.Entry(avaliacao.Atleta).Reference(p => p.Pessoa).Load();
if (avaliacao == null)
{
return(HttpNotFound());
}
return(View(avaliacao));
}
public void Carregar(Avaliacao avaliacao)
{
if (avaliacao.GetId() <= 0)
{
throw new ExcecaoSAG("Obrigatório selecionar uma avaliação.");
}
try
{
avaliacaoDAO.Carregar(avaliacao);
}
catch (ExcecaoSAG ex)
{
throw new ExcecaoSAG(ex.getMsg());
}
}
public Avaliacao Get(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new Exception("Id não encontrado");
}
Avaliacao avaliacao = _avaliacaoRepository.Get(id);
if (avaliacao == null)
{
throw new Exception("Usuário não encontrado");
}
return(avaliacao);
}
public ActionResult AdicionarAvaliacao()
{
var aluno = new AlunosDAO();
var lista = aluno.ListarAlunos();
ViewBag.ListarAluno = lista;
var disciplina = new DisciplinasDAO();
IList <Disciplina> listas = disciplina.ListarDisciplinas();
ViewBag.ListaDisciplina = listas;
var avaliacao = new Avaliacao();
return(View(avaliacao));
}
public async Task <Avaliacao> EditAsync(Avaliacao entity, int key)
{
if (entity == null)
{
return(null);
}
Avaliacao existing = DataContext.Set <Avaliacao>().Find(key);
if (existing != null)
{
DataContext.Entry(existing).CurrentValues.SetValues(entity);
await DataContext.SaveChangesAsync();
}
return(existing);
}
public void UpdateAvaliacao(Avaliacao avaliacao)
{
using (SqlConnection con = new SqlConnection(_connectionString))
{
con.Open();
string query = "UPDATE avaliacoes SET nome = @nome, cidade = @cidade, estado = @estado WHERE id = @id";
SqlCommand cmd = new SqlCommand(query, con);
cmd.Parameters.AddWithValue("@id", avaliacao.Id);
cmd.Parameters.AddWithValue("@nome", avaliacao.nome);
cmd.Parameters.AddWithValue("@cidade", avaliacao.cidade);
cmd.Parameters.AddWithValue("@estado", avaliacao.estado);
cmd.ExecuteNonQuery();
}
}
public frmVisualizarAvaliacao()
{
InitializeComponent();
//Trazer OBJ ALUNO
Aluno a = AlunoDAO.BuscarAlunoPorCPF(Login.cpfLogin);
//Buscar avaliações por aluno
Avaliacao p = AvaliacaoDAO.BuscarAvaliacaoPorIdAluno(a.idAluno);
// Avaliacao paux = AvaliacaoDAO.BuscarAvaliacaoPorId(a.idAluno);
txtCpf.Text = p.professor.cpf;
txtData.Text = p.dataMarcada.ToString();
txtNome.Text = p.professor.nome;
txtData_Copy.Text = p.statusAvaliacao;
}
public List <Avaliacao> BuscarTodos()
{
var lst = new List <Avaliacao>();
using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Db"].ConnectionString))
{
string strSQL = @"select
a.*,
u.nome as Nome_Professor
from Avaliacao a
inner join Usuario u on u.cod = a.codProfessor";
using (SqlCommand cmd = new SqlCommand(strSQL))
{
conn.Open();
cmd.Connection = conn;
cmd.CommandText = strSQL;
var dataReader = cmd.ExecuteReader();
var dt = new DataTable();
dt.Load(dataReader);
conn.Close();
foreach (DataRow row in dt.Rows)
{
var avaliacao = new Avaliacao()
{
Cod = Convert.ToInt32(row["cod"]),
Texto = row["texto"].ToString(),
Valor = Convert.ToInt32(row["valor"]),
Professor = new Usuario()
{
Cod = Convert.ToInt32(row["codProfessor"]),
Nome = row["Nome_Professor"].ToString()
},
Redacao = new Redacao()
{
Cod = Convert.ToInt32(row["codRedacao"])
}
};
lst.Add(avaliacao);
}
}
}
return(lst);
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Avaliacao = await _context.Avaliacao.FindAsync(id);
if (Avaliacao != null)
{
_context.Avaliacao.Remove(Avaliacao);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public void Handle(AdicionarAvaliacaoCommand cmd)
{
Avaliacao avaliacao = new Avaliacao(cmd.Nota, cmd.Descricao, DateTime.Now, cmd.EventoId, cmd.ClienteId);
if (!avaliacao.IsValid())
{
NotificarValidacoesErro(avaliacao.ValidationResult);
return;
}
_repository.IncluirAvaliacao(avaliacao);
if (Commit())
{
_mediator.PublicarEvento(new AvaliacaoAdicionadaEvent(avaliacao.Nota, avaliacao.Descricao, avaliacao.DataHora, avaliacao.EventoId, avaliacao.ClienteId));
}
}
public void mustUpdateAModel()
{
mustSaveAModel();
Avaliacao _Avaliacao = new Avaliacao(_workspace);
_Avaliacao.Load(1);
_Avaliacao.Comentario = "Sem Testes";
_Avaliacao.Update();
Avaliacao _AvaliacaoResultado = new Avaliacao(_workspace);
_AvaliacaoResultado.Load(1);
Assert.AreEqual(_AvaliacaoResultado.Comentario, "Sem Testes");
_Avaliacao.Delete();
}
public void RegistrarComentario(Avaliacao avaliacao)
{
if (avaliacao.AvaliacaoID == 0)
{
_context.Avaliacoes.Add(avaliacao);
}
else
{
Avaliacao dbEntry = _context.Avaliacoes
.FirstOrDefault(c => c.AvaliacaoID == avaliacao.AvaliacaoID);
if (dbEntry != null)
{
_context.Avaliacoes.Update(avaliacao);
}
}
_context.SaveChanges();
}
public IEnumerable <Avaliacao> GetAllAvaliacoes()
{
using (var connection = new SqlConnection(_connectionString))
{
var commandText = "SELECT * FROM avaliacoes ORDER BY total_avaliacoes DESC";
var selectCommand = new SqlCommand(commandText, connection);
Avaliacao avaliacao = null;
var avaliacoes = new List <Avaliacao>();
try
{
connection.Open();
using (var reader = selectCommand.ExecuteReader(CommandBehavior.CloseConnection))
{
while (reader.Read())
{
avaliacao = new Avaliacao();
avaliacao.Id = (int)reader["id"];
avaliacao.nome = reader["nome"].ToString();
avaliacao.cidade = reader["cidade"].ToString();
avaliacao.estado = reader["Estado"].ToString();
avaliacao.tipo = reader["tipo"].ToString();
avaliacao.totalAvaliacoes = (int)reader["total_avaliacoes"];
avaliacao.servAgilidade = (int)reader["serv_agilidade"];
avaliacao.servAtendimento = (int)reader["serv_atendimento"];
avaliacao.servsatisfacao = (int)reader["serv_satisfacao"];
avaliacao.prodQualidade = (int)reader["prod_qualidade"];
avaliacao.prodCusto_beneficio = (int)reader["prod_custo_beneficio"];
avaliacao.prodSatisfacao = (int)reader["prod_satisfacao"];
avaliacao._data = DateTime.Parse(reader["_data"].ToString());
avaliacoes.Add(avaliacao);
}
}
}
finally
{
connection.Close();
}
return(avaliacoes);
}
}
public static string pesquisaTitulo(int id)
{
Avaliacao avaliacao = new Avaliacao(id);
return avaliacao.titulo;
}
