public void respuestasPorAnios()
{
DataBase db = new DataBase();
//Comprobamos que cargo los valores por defecto
Estadisticas estadisticas = db.getEstadisticas();
DataTable dataTable = estadisticas.respuestasPorAnios();
Assert.AreEqual(dataTable.Rows[0][0], "2018");
Assert.AreEqual(dataTable.Rows[0][1], 30);
Assert.AreEqual(dataTable.Rows[1][0], "2017");
Assert.AreEqual(dataTable.Rows[1][1], 10);
//Comprobamos que si añadimos una resuesta del 2016 nos lo contabiliza
Valoracion valoracion = new Valoracion(4, "muy buena", new DateTime(2016, 12, 12, 14, 30, 15));
db.getEncuesta("Encuesta1").setOpinionCSV(valoracion);
estadisticas = db.getEstadisticas();
dataTable = estadisticas.respuestasPorAnios();
Assert.AreEqual(dataTable.Rows[0][0], "2018");
Assert.AreEqual(dataTable.Rows[0][1], 30);
Assert.AreEqual(dataTable.Rows[1][0], "2017");
Assert.AreEqual(dataTable.Rows[1][1], 10);
Assert.AreEqual(dataTable.Rows[2][0], "2016");
Assert.AreEqual(dataTable.Rows[2][1], 1);
}
public bool registraValoracion(long?codigo_venta, long?valoracion, long?usuario_id, long?producto_id)
{
try
{
IValoracion ObjValoracion = new Valoracion();
ObjValoracion.CALIFICACION = valoracion.GetValueOrDefault();
ObjValoracion.NUMERO_VENTA = codigo_venta.GetValueOrDefault();
ObjValoracion.Producto = new Producto {
ID_PRODUCTO = producto_id.GetValueOrDefault()
};
ObjValoracion.Usuario = new Usuario {
ID_USUARIO = usuario_id.GetValueOrDefault()
};
this.BeginTransaction();
this.Save(ObjValoracion);
this.Commit();
return(true);
}
catch (Exception error)
{
log.Error("->ERROR DE SISTEMA", error);
this.Rollback();
}
finally
{
}
return(false);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Fecha,Puntuacion")] Valoracion valoracion)
{
if (id != valoracion.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _valoracionesServices.UpdateValoracionAsync(valoracion);
}
catch (DbUpdateConcurrencyException)
{
if (!_valoracionesServices.ValoracionExists(valoracion.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(valoracion));
}
public async Task <IActionResult> Valoracion(int id)
{
var valoracion = new Valoracion();
valoracion.IdReto = id;
return(View(valoracion));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Puntuacion,NumeroPuntuaciones,MediaPuntuaciones,RetoId")] Valoracion valoracion)
{
if (id != valoracion.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(valoracion);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ValoracionExists(valoracion.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["RetoId"] = new SelectList(_context.Reto, "Id", "Id", valoracion.RetoId);
return(View(valoracion));
}
/*El delivery califica al cliente y finaliza*/
public static bool CrearValoracionCliente(Valoracion valoracion)
{
using (TeloBuscoEntities db = new TeloBuscoEntities())
{
try
{
bool result = false;
Valoraciones val = new Valoraciones
{
IdCliente = valoracion.IdCliente,
IdDelivery = valoracion.IdDelivery,
Valoracion = valoracion.Puntuacion,
Comentario = valoracion.Comentario,
IdPedido = valoracion.IdPedido,
valoracion_cliente = false,
valoracion_delivery = true
};
if (PedidosServicio.FinalizarPedidoDelivery(valoracion.IdPedido)) //Finalizo el pedido -> si está ok agrego la valoración
{
db.Valoraciones.Add(val);
db.SaveChanges();
result = true;
}
return(result);
}
catch (Exception ex)
{
return(false);
}
}
}
public ActionResult Valorar(ValoracionesViewModel valoracion)
{
try
{
var pedido = Servicios.AccesoDatos.PedidosServicio.ObtenerPedidoPorId(valoracion.IdPedido);
Valoracion val = new Valoracion
{
IdCliente = pedido.idCliente,
IdDelivery = pedido.idDelivery,
Puntuacion = valoracion.Puntuacion,
Comentario = valoracion.Comentario,
IdPedido = valoracion.IdPedido
};
if (Servicios.AccesoDatos.ValoracionesServicios.Crear(val))
{
TempData["Message"] = "Gracias por tu colaboracion!";
}
else
{
TempData["Message"] = "Ups";
};
return(RedirectToAction("PedidosCliente"));
}
catch
{
return(View());
}
}
public void TestConstructorSetyGet()
{
// Prueba Valor correcto
Valoracion valoracion = new Valoracion(4, "muy buena");
Assert.AreEqual(valoracion.Valor, 4);
Assert.AreEqual(valoracion.Opinion, "muy buena");
// Prueba Valor mayor que 4
Valoracion valoracion1 = new Valoracion(10, "la mejor");
Assert.AreEqual(valoracion1.Valor, 0);
Assert.AreEqual(valoracion1.Opinion, "la mejor");
// Prueba Valor menor que 1
Valoracion valoracion2 = new Valoracion(-1, "la peor");
Assert.AreEqual(valoracion2.Valor, 0);
Assert.AreEqual(valoracion2.Opinion, "la peor");
// Prueba metodo set valor
valoracion2.Valor = 4;
Assert.AreEqual(valoracion2.Valor, 4);
// Prueba metodo set opinion
valoracion2.Opinion = "la mejor";
Assert.AreEqual(valoracion2.Opinion, "la mejor");
}
public async Task <IActionResult> Edit(int id, [Bind("Idvaloracion,Idpedido,Valor,Comentario")] Valoracion valoracion)
{
if (id != valoracion.Idvaloracion)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(valoracion);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ValoracionExists(valoracion.Idvaloracion))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["Idpedido"] = new SelectList(_context.Pedido, "Idpedido", "Idpedido", valoracion.Idpedido);
return(View(valoracion));
}
public ActionResult ValorarCliente(ValoracionesViewModel valoracion)
{
try
{
Valoracion val = new Valoracion
{
IdCliente = valoracion.IdCliente,
IdDelivery = valoracion.IdDelivery,
Puntuacion = valoracion.Puntuacion,
Comentario = valoracion.Comentario,
IdPedido = valoracion.IdPedido
};
if (Servicios.AccesoDatos.ValoracionesServicios.CrearValoracionCliente(val))
{
TempData["Message"] = "¡Gracias por tu colaboración!";
}
else
{
TempData["Message"] = "Ups. Tu pedido no pudo ser finalizado.";
};
return(RedirectToAction("PedidosAsignados", "Pedidos"));
}
catch
{
return(View());
}
}
public IActionResult Post([FromBody] Valoracion valoracionP)
{
Ctrl_ValorarPaciente ctrlC = new Ctrl_ValorarPaciente();
List <Valoracion> valoracion = new List <Valoracion>();
try
{
if (ModelState.IsValid)
{
if (ctrlC.verificarCedula(valoracionP.cedula) == false && ctrlC.solicitarHistoriaClinica(valoracionP.cedula) == true)
{
valoracion.Add(valoracionP);
}
else
{
valoracion.Clear();
}
return(new CreatedAtRouteResult("La valoración del paciente ha sido creada", new { valoracionP }));
}
}
catch (CedulaYaExisteException ex)
{
return(BadRequest(ex.Message));
}
catch (HistoriaClinicaNoDisponibleException ex)
{
return(BadRequest(ex.Message));
}
return(BadRequest(ModelState));
}
public void GetNumberOfValoracionesByVendedorWithNonExistentVendedorIdTest()
{
UserProfile userProfile = CreateTestUserProfile();
Valoracion valoracion = CreateTestValoracion(userProfile.usrId, 4);
Valoracion valoracion1 = CreateTestValoracion(userProfile.usrId, 3);
Assert.IsTrue(opinadorService.FindValoracionesAndNoteByVendedor(NON_EXISTENT_VENDEDOR_ID, START_INDEX, COUNT).NumValoraciones == 0);
}
public ActionResult DeleteConfirmed(int id)
{
Valoracion valoracion = db.Valoracions.Find(id);
db.Valoracions.Remove(valoracion);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void GetValoracionMediaByVendedorTest()
{
UserProfile userProfile = CreateTestUserProfile();
Valoracion valoracion = CreateTestValoracion(userProfile.usrId, 4);
Valoracion valoracion1 = CreateTestValoracion(userProfile.usrId, 3);
double valoracionMedia = opinadorService.FindValoracionesAndNoteByVendedor(VENDEDOR_ID, START_INDEX, COUNT).AverageValoracion;
Assert.AreEqual(valoracionMedia, 3.5);
}
public void ValorarUsuarioTest()
{
UserProfile userProfile = CreateTestUserProfile();
Valoracion valoracion = opinadorService.ValorarUsuario(VENDEDOR_ID, userProfile.usrId, 4, "texto");
List <Valoracion> valoraciones = opinadorService.FindValoracionesAndNoteByVendedor(VENDEDOR_ID, START_INDEX, COUNT).Valoraciones;
Assert.IsTrue(valoraciones.Count == 1);
Assert.IsTrue(valoraciones.Contains(valoracion));
}
public async Task <IActionResult> Create([Bind("Id,Fecha,Puntuacion")] Valoracion valoracion)
{
if (ModelState.IsValid)
{
await _valoracionesServices.CreateValoracionAsync(valoracion);
return(RedirectToAction(nameof(Index)));
}
return(View(valoracion));
}
public async Task <IActionResult> GuardarValoracion([Bind("IdReto,Puntuacion")] Valoracion valoracion)
{
Usuario usuario = await _userManager.GetUserAsync(User);
valoracion.IdUsuario = usuario.IdUsuario;
_context.Add(valoracion);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
/// <exception cref="InstanceNotFoundException">If usrId doesn't match an existing UserProfile</exception>
public Valoracion ValorarUsuario(string vendedorId, long usrId, int voto, string text)
{
Valoracion valoracion = Valoracion.CreateValoracion(-1, voto, DateTime.Now, usrId, vendedorId);
if (text != null)
{
valoracion.comentario = text;
}
valoracion.UserProfile = UserProfileDao.Find(usrId);
ValoracionDao.Create(valoracion);
return(valoracion);
}
public void FindValoracionesByVendedorWithNonExistentVendedorIdTest()
{
UserProfile userProfile = CreateTestUserProfile();
Valoracion valoracion = CreateTestValoracion(userProfile.usrId, 4);
Valoracion valoracion1 = CreateTestValoracion(userProfile.usrId, 3);
ValoracionBlock valoracionesBlock = opinadorService.FindValoracionesAndNoteByVendedor(NON_EXISTENT_VENDEDOR_ID, START_INDEX, COUNT);
Assert.IsTrue(valoracionesBlock.Valoraciones.Count == 0);
Assert.IsFalse(valoracionesBlock.Valoraciones.Contains(valoracion));
Assert.IsFalse(valoracionesBlock.Valoraciones.Contains(valoracion1));
}
public async Task <IActionResult> Create([Bind("Idvaloracion,Idpedido,Valor,Comentario")] Valoracion valoracion)
{
if (ModelState.IsValid)
{
_context.Add(valoracion);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["Idpedido"] = new SelectList(_context.Pedido, "Idpedido", "Idpedido", valoracion.Idpedido);
return(View(valoracion));
}
public async Task <IActionResult> Create([Bind("Id,Puntuacion,NumeroPuntuaciones,MediaPuntuaciones,RetoId")] Valoracion valoracion)
{
if (ModelState.IsValid)
{
_context.Add(valoracion);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["RetoId"] = new SelectList(_context.Reto, "Id", "Id", valoracion.RetoId);
return(View(valoracion));
}
// GET: Valoracions/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Valoracion valoracion = db.Valoracions.Find(id);
if (valoracion == null)
{
return(HttpNotFound());
}
return(View(valoracion));
}
public void FindValoracionesAndNoteByVendedorTest()
{
UserProfile userProfile = CreateTestUserProfile();
Valoracion v1 = opinadorService.ValorarUsuario(VENDEDOR_ID, userProfile.usrId, 2, "voto1");
opinadorService.ValorarUsuario(VENDEDOR_ID, userProfile.usrId, 4, "voto2");
opinadorService.ValorarUsuario(VENDEDOR_ID, userProfile.usrId, 3, "voto3");
ValoracionBlock valoracionBlock = opinadorService.FindValoracionesAndNoteByVendedor(VENDEDOR_ID, START_INDEX, COUNT);
Assert.IsTrue(valoracionBlock.NumValoraciones == 3);
Assert.IsTrue(valoracionBlock.AverageValoracion == 3);
Assert.IsTrue(valoracionBlock.Valoraciones.Contains(v1));
}
public ActionResult Edit([Bind(Include = "ValoracionID,Descripcion,Valor")] Valoracion valoracion)
{
if (db.Valoracions.Any(v => v.Valor == valoracion.Valor))
{
ModelState.AddModelError("", "Valor repetido, agregue otro diferente");
return(View(valoracion));
}
if (ModelState.IsValid)
{
db.Entry(valoracion).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(valoracion));
}
protected void dtlOferta_ItemCommand(object source, DataListCommandEventArgs e)
{
Decimal puntosAcumulados = 0;
List <Modelo.Ofertas> oferta = (List <Modelo.Ofertas>)Session["Oferta"];
LnValoracion lnValoracion = new LnValoracion();
LnUsuario lnUsuario = new LnUsuario();
var usuario = lnUsuario.BuscarUsuarioMail((string)(Session["consumidorEmail"]));
if (e.CommandName == "RegistrarValoracion")
{
if (0 != Convert.ToDecimal(((DropDownList)e.Item.FindControl("ddlValoracion")).SelectedValue.ToString()))
{
puntosAcumulados = usuario.PUNTOS_USUARIO + 10;
Usuario us = new Usuario();
{
us.rut_usuario = usuario.RUT_USUARIO;
us.nombre_usuario = usuario.NOMBRE_USUARIO;
us.apema_usuario = usuario.APEMA_USUARIO;
us.apepa_usuario = usuario.APEPA_USUARIO;
us.correo_usuario = usuario.CORREO_USUARIO;
us.direccion_usuario = usuario.DIRECCION_USUARIO;
us.telefono_usuario = usuario.TELEFONO_USUARIO;
us.password_usuario = usuario.PASSWORD_USUARIO;
us.correoactivo = usuario.CORREOACTIVO;
us.puntos_usuario = puntosAcumulados;
us.id_tipoUsuario = usuario.ID_TIPOUSUARIO;
us.id_comuna = usuario.ID_COMUNA;
}
foreach (var item in oferta)
{
Valoracion valoracion = new Valoracion();
{
valoracion.id_oferta = item.id_oferta;
valoracion.id_valoracion = Convert.ToDecimal(1);
valoracion.imagen_boleta = traerImagen((FileUpload)e.Item.FindControl("flSubir"));
valoracion.numero_boleta = Convert.ToDecimal(((TextBox)e.Item.FindControl("txtNumeroBoleta")).Text);
valoracion.rut_usuario = usuario.RUT_USUARIO;
valoracion.calificacion = Convert.ToDecimal(((DropDownList)e.Item.FindControl("ddlValoracion")).SelectedValue.ToString());
}
lnValoracion.InsertarValoracionOferta(valoracion, us);
}
Response.Redirect("../../Views/ConsultarPuntos/ConsultarPuntos.aspx");
}
else
{
}
}
}
public List <Valoracion> RankingDocentes(string nombreCurso)
{
List <Valoracion> valoracionEncontrados = new List <Valoracion>();
Valoracion valoracionEncontrado = null;
string sql = "dbo.ssp_Valoracion_RankingDocentes";
using (SqlConnection conexion = new SqlConnection(cadenaConexion))
{
conexion.Open();
using (SqlCommand comando = new SqlCommand(sql, conexion))
{
comando.CommandType = System.Data.CommandType.StoredProcedure;
comando.Parameters.Add(new SqlParameter("@NombreCurso", nombreCurso));
using (SqlDataReader resultado = comando.ExecuteReader())
{
while (resultado.Read())
{
var estrellas_promedio = (decimal)resultado["estrellas_promedio"];
valoracionEncontrado = new Valoracion()
{
docente = new Docente()
{
id = (int)resultado["id_docente"],
nombres = (string)resultado["nombres_docente"],
apellidos = (string)resultado["apellidos_docente"]
},
sede = new Sede()
{
nombre = (string)resultado["nombre_sede"]
},
curso = new Curso()
{
id = (int)resultado["id_curso"],
nombre = (string)resultado["nombre_curso"],
},
cantidad = (int)resultado["cantidad_valoraciones"],
estrellas_promedio = (decimal)resultado["estrellas_promedio"]
};
valoracionEncontrados.Add(valoracionEncontrado);
}
}
}
}
return(valoracionEncontrados);
}
public void TestConstructorSetyGet()
{
// Prueba Valor correcto
Valoracion valoracion = new Valoracion(4, "muy buena", new DateTime(2015, 5, 16, 14, 30, 15));
Assert.AreEqual(valoracion.Valor, 4);
Assert.AreEqual(valoracion.Opinion, "muy buena");
// Prueba Valor mayor que 4
Valoracion valoracion1 = new Valoracion(10, "la mejor", new DateTime(2016, 5, 16, 14, 30, 15));
Assert.AreEqual(valoracion1.Valor, 0);
Assert.AreEqual(valoracion1.Opinion, "la mejor");
// Prueba Valor menor que 1
Valoracion valoracion2 = new Valoracion(-1, "la peor", new DateTime(2017, 5, 16, 14, 30, 15));
Assert.AreEqual(valoracion2.Valor, 0);
Assert.AreEqual(valoracion2.Opinion, "la peor");
// Prueba metodo set valor
valoracion2.Valor = 4;
Assert.AreEqual(valoracion2.Valor, 4);
// Prueba metodo set opinion
valoracion2.Opinion = "la mejor";
Assert.AreEqual(valoracion2.Opinion, "la mejor");
//Prueba metodo get fecha
Assert.AreEqual(valoracion.Fecha.ToString(), "16/05/2015 14:30:15");
Assert.AreEqual(valoracion1.Fecha.ToString(), "16/05/2016 14:30:15");
Assert.AreEqual(valoracion2.Fecha.ToString(), "16/05/2017 14:30:15");
//Prueba metodo set fecha
valoracion.Fecha = new DateTime(2018, 12, 1, 19, 10, 15);
valoracion1.Fecha = new DateTime(2018, 12, 1, 19, 11, 15);
valoracion2.Fecha = new DateTime(2018, 12, 1, 19, 12, 15);
Assert.AreEqual(valoracion.Fecha, new DateTime(2018, 12, 1, 19, 10, 15));
Assert.AreEqual(valoracion1.Fecha, new DateTime(2018, 12, 1, 19, 11, 15));
Assert.AreEqual(valoracion2.Fecha, new DateTime(2018, 12, 1, 19, 12, 15));
}
// GET: Valraciones
// GET: Valraciones/Details/5
public ActionResult Guardar(ValoracionesViewModel valoracion)
{
try
{
Valoracion puntaje = new Valoracion
{
IdValoracion = valoracion.IdValoracion,
IdCliente = valoracion.IdCliente,
IdDelivery = valoracion.IdCliente,
Puntuacion = valoracion.Puntuacion,
Comentario = valoracion.Comentario
};
if (Servicios.AccesoDatos.ValoracionesServicios.Crear(puntaje))
{
return(View());
}
}
catch {
}
return(View());
}
public void respuestasPorMeses()
{
DataBase db = new DataBase();
//Comprobamos que cargo los valores por defecto
Estadisticas estadisticas = db.getEstadisticas();
DataTable dataTable = estadisticas.respuestasPorMeses();
Assert.AreEqual(dataTable.Rows[0][0], "Febrero");
Assert.AreEqual(dataTable.Rows[0][1], 7);
Assert.AreEqual(dataTable.Rows[8][0], "Diciembre");
Assert.AreEqual(dataTable.Rows[8][1], 1);
//Comprobamos que si añadimos una resuesta de diciembre nos los contabiliza
Valoracion valoracion = new Valoracion(4, "muy buena", new DateTime(2016, 12, 12, 14, 30, 15));
db.getEncuesta("Encuesta1").setOpinionCSV(valoracion);
estadisticas = db.getEstadisticas();
dataTable = estadisticas.respuestasPorMeses();
Assert.AreEqual(dataTable.Rows[0][0], "Febrero");
Assert.AreEqual(dataTable.Rows[0][1], 7);
Assert.AreEqual(dataTable.Rows[8][0], "Diciembre");
Assert.AreEqual(dataTable.Rows[8][1], 2);
}
public async Task UpdateValoracionAsync(Valoracion valoracion)
{
_context.Update(valoracion);
await _context.SaveChangesAsync();
}
