commit 2f861d3546fa0665a17491bac6f272c5a093f6ec Author: NataliaCancinoV Date: Sat May 25 16:24:00 2024 -0600 Backend diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..c5f3f6b --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "java.configuration.updateBuildConfiguration": "interactive" +} \ No newline at end of file diff --git a/backend/pom.xml b/backend/pom.xml new file mode 100644 index 0000000..7318efd --- /dev/null +++ b/backend/pom.xml @@ -0,0 +1,90 @@ + + + + 4.0.0 + + mx.uv + backend + 1.0-SNAPSHOT + + backend + + http://www.example.com + + + UTF-8 + 18 + 18 + + + + + junit + junit + 4.11 + test + + + + com.sparkjava + spark-core + 2.9.4 + + + + org.slf4j + slf4j-simple + 1.7.21 + + + + com.google.code.gson + gson + 2.8.6 + + + + mysql + mysql-connector-java + 8.0.30 + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 2.3.2 + + 1.8 + 1.8 + + + + maven-assembly-plugin + + + package + + single + + + + + + + jar-with-dependencies + + + + mx.uv.App + + + + + + + + \ No newline at end of file diff --git a/backend/src/main/java/mx/uv/App.java b/backend/src/main/java/mx/uv/App.java new file mode 100644 index 0000000..2eb85ea --- /dev/null +++ b/backend/src/main/java/mx/uv/App.java @@ -0,0 +1,630 @@ +package mx.uv; + +/** + * Hello world! + * + */ + +import static spark.Spark.*; + +import java.util.HashMap; +import java.util.List; +import java.util.UUID; +import com.google.gson.*; + +public class App +{ + static Gson gson = new Gson(); + static HashMap usuarios = new HashMap(); + static String correoG; + static String passwordG; + static String nombreG; + static String idG; + public static void main( String[] args ) + { + System.out.println( "Hello World!" ); + + //port(80); + port(getHerokuAssignedPort()); + + options("/*", (request, response) -> { + + String accessControlRequestHeaders = request.headers("Access-Control-Request-Headers"); + if (accessControlRequestHeaders != null) { + response.header("Access-Control-Allow-Headers", accessControlRequestHeaders); + } + + String accessControlRequestMethod = request.headers("Access-Control-Request-Method"); + if (accessControlRequestMethod != null) { + response.header("Access-Control-Allow-Methods", accessControlRequestMethod); + } + + return "OK"; + }); + before((request, response) -> response.header("Access-Control-Allow-Origin", "*")); + + get("/backend/verificar-conexion", (request, response) -> { + response.type("application/json"); + + JsonObject respuesta = new JsonObject(); + respuesta.addProperty("mensaje", "Conexión exitosa al backend"); + + return respuesta.toString(); + }); + + post("/frontend/", (request, response)->{ + response.type("application/json"); + String payload = request.body(); + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + Usuario usuario = gson.fromJson(jsonObject.get("datosFormulario"), Usuario.class); + System.out.println("usuario"+usuario); + System.out.println("payload "+payload); + String id = UUID.randomUUID().toString(); + usuario.setId(id); + usuarios.put(id, usuario); + DAO.crearUsuario(usuario); + System.out.println("i "+usuario.getId()); + System.out.println("n "+usuario.getCorreo()); + System.out.println("p "+usuario.getPassword()); + JsonObject respuesta = new JsonObject(); + respuesta.addProperty("msj", "Se creo el usuario"); + respuesta.addProperty("id", id); + return gson.toJson(usuario); + }); + + post("/frontend/correoExiste", (request, response) -> { + response.type("application/json"); + + // Obtener datos del formulario enviado + String payload = request.body(); + + // Parsear el cuerpo JSON + JsonObject jsonObject = JsonParser.parseString(payload).getAsJsonObject(); + + // Acceder a la clave "datosFormulario" y luego obtener la clave "correo" + String correo = jsonObject.getAsJsonObject("datosFormulario").get("correo").getAsString(); + + System.out.println("correo: "+correo); + // Verificar si el correo existe + boolean correoExistente = DAO.correoExistente(correo); + + // Construir un objeto JSON con la información sobre si el correo existe + JsonObject resultadoJson = new JsonObject(); + resultadoJson.addProperty("correoExistente", correoExistente); + + return resultadoJson.toString(); + }); + + post("/frontend/obtenerUsuario", (request, response) -> { + response.type("application/json"); + + // Puedes acceder a las variables globales directamente o utilizar métodos getter según tu implementación + String correo = correoG; + String password = passwordG; + String nombre = nombreG; + + // Construir un objeto JSON con los datos del usuario + JsonObject usuarioJson = new JsonObject(); + usuarioJson.addProperty("correo", correo); + usuarioJson.addProperty("password", password); + usuarioJson.addProperty("nombre", nombre); + System.out.println(nombre);; + System.out.println(usuarioJson); + return usuarioJson.toString(); + }); + + post("/frontend/login", (request, response)->{ + response.type("application/json"); + String payload = request.body(); + System.out.println("payload "+payload); + // DAO.crearUsuario(usuario); + + String correo = ""; + String password = ""; + + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + // Accede a la clave "datosFormulario" y luego obtén las claves "correo" y "password" + JsonObject datosFormulario = jsonObject.getAsJsonObject("datosFormulario"); + + if (datosFormulario != null && datosFormulario.has("correo") && datosFormulario.has("password")) { + correo = datosFormulario.get("correo").getAsString(); + password = datosFormulario.get("password").getAsString(); + System.out.println("Correogson: " + correo); + System.out.println("Passwordgson: " + password); + } else { + System.out.println("Las claves 'correo' y/o 'password' no están presentes en el JSON."); + } + boolean esUsuarioValido = DAO.validarUsuario(correo, password); + JsonObject respuesta = new JsonObject(); + if (esUsuarioValido) { + correoG = correo; + passwordG = password; + String id = DAO.obtenerIdUsuario(correoG,passwordG); + idG = id; + System.out.println("correo valido "+correoG); + System.out.println("password valido "+passwordG); + System.out.println("id valido "+passwordG); + + + Usuario usuario = DAO.obtenerDatosUsuario(id); + nombreG = usuario.getNombre(); + System.out.println("nombre valido: "+nombreG); + respuesta.addProperty("msj", "Valido"); + respuesta.addProperty("nombre", usuario.getNombre()); + respuesta.addProperty("id", id); + return gson.toJson(usuario); + } else { + respuesta.addProperty("msj", "Invalido"); + return "Invalido"; + } + }); + + post("/Login", (request, response) -> { + response.type("application/json"); + + // Puedes acceder a las variables globales directamente o utilizar métodos getter según tu implementación + String correo = correoG; + String password = passwordG; + String nombre = nombreG; + + // Construir un objeto JSON con los datos del usuario + JsonObject usuarioJson = new JsonObject(); + usuarioJson.addProperty("correo", correo); + usuarioJson.addProperty("password", password); + usuarioJson.addProperty("nombre", nombre); + System.out.println(nombre);; + System.out.println(usuarioJson); + return usuarioJson.toString(); + }); + + + post("/frontend/cerrarSesion", (request, response) -> { + response.type("application/json"); + + // Establecer las variables a null + correoG = null; + passwordG = null; + nombreG = null; + idG = null; + + String correo = correoG; + String password = passwordG; + String nombre = nombreG; + + // Construir un objeto JSON con los datos del usuario + JsonObject usuarioJson = new JsonObject(); + usuarioJson.addProperty("correo", correo); + usuarioJson.addProperty("password", password); + usuarioJson.addProperty("nombre", nombre); + usuarioJson.addProperty("id", idG); + + System.out.println(usuarioJson); + return usuarioJson.toString(); + }); + + + post("/frontend/login", (request, response)->{ + response.type("application/json"); + String payload = request.body(); + System.out.println("payload "+payload); + // DAO.crearUsuario(usuario); + + String correo = ""; + String password = ""; + + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + // Accede a la clave "datosFormulario" y luego obtén las claves "correo" y "password" + JsonObject datosFormulario = jsonObject.getAsJsonObject("datosFormulario"); + + if (datosFormulario != null && datosFormulario.has("correo") && datosFormulario.has("password")) { + correo = datosFormulario.get("correo").getAsString(); + password = datosFormulario.get("password").getAsString(); + System.out.println("Correogson: " + correo); + System.out.println("Passwordgson: " + password); + } else { + System.out.println("Las claves 'correo' y/o 'password' no están presentes en el JSON."); + } + boolean esUsuarioValido = DAO.validarUsuario(correo, password); + JsonObject respuesta = new JsonObject(); + if (esUsuarioValido) { + correoG = correo; + passwordG = password; + String id = DAO.obtenerIdUsuario(correoG,passwordG); + idG = id; + System.out.println("correo valido "+correoG); + System.out.println("password valido "+passwordG); + System.out.println("id valido "+passwordG); + + + Usuario usuario = DAO.obtenerDatosUsuario(id); + nombreG = usuario.getNombre(); + System.out.println("nombre valido: "+nombreG); + respuesta.addProperty("msj", "Valido"); + respuesta.addProperty("nombre", usuario.getNombre()); + respuesta.addProperty("id", id); + return gson.toJson(usuario); + } else { + respuesta.addProperty("msj", "Invalido"); + return "Invalido"; + } + }); + + + //Recuperar Contraseña: + + post("/frontend/RecuperarContra", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + System.out.println(payload); + + String correo = ""; + String password = ""; + + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + JsonObject datosFormulario = jsonObject.getAsJsonObject("datosFormulario"); + + if (datosFormulario != null && datosFormulario.has("correo") && datosFormulario.has("password")) { + correo = datosFormulario.get("correo").getAsString(); + password = datosFormulario.get("password").getAsString(); + System.out.println("Correo: " + correo); + System.out.println("Password: " + password); + } else { + System.out.println("Las claves 'correo' y/o 'password' no están presentes en el JSON."); + } + boolean existeUsuario = DAO.existeUsuarioPorCorreo(correo); + JsonObject respuesta = new JsonObject(); + if (existeUsuario) { + + respuesta.addProperty("msj", "Usuario encontrado"); + return "Usuario encontrado"; + } else { + respuesta.addProperty("msj", "Usuario no encontrado"); + return "Usuario no encontrado"; + } + }); + + post("/frontend/ColocarContra2", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + + String correo = ""; + String password = ""; + + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + JsonObject datosFormulario = jsonObject.getAsJsonObject("datosFormulario"); + + if (datosFormulario != null && datosFormulario.has("correo") && datosFormulario.has("password")) { + correo = datosFormulario.get("correo").getAsString(); + password = datosFormulario.get("password").getAsString(); + System.out.println("Correo: " + correo); + System.out.println("Password: " + password); + } else { + System.out.println("Las claves 'correo' y/o 'password' no están presentes en el JSON."); + } + System.out.println(correo); + System.out.println(password); + DAO.cambiarContrasena(correo, password); + + System.out.println(payload); + return "Actualizado"; + }); + + post("/frontend/RecuperarContra", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + System.out.println(payload); + + String correo = ""; + String password = ""; + + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + JsonObject datosFormulario = jsonObject.getAsJsonObject("datosFormulario"); + + if (datosFormulario != null && datosFormulario.has("correo") && datosFormulario.has("password")) { + correo = datosFormulario.get("correo").getAsString(); + password = datosFormulario.get("password").getAsString(); + System.out.println("Correo: " + correo); + System.out.println("Password: " + password); + } else { + System.out.println("Las claves 'correo' y/o 'password' no están presentes en el JSON."); + } + boolean existeUsuario = DAO.existeUsuarioPorCorreo(correo); + JsonObject respuesta = new JsonObject(); + if (existeUsuario) { + + respuesta.addProperty("msj", "Usuario encontrado"); + return "Usuario encontrado"; + } else { + respuesta.addProperty("msj", "Usuario no encontrado"); + return "Usuario no encontrado"; + } + }); + + + + //Hacer Reservaciones: + + post("/frontend/hacerPedidoPastel1", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + + try { + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + // Obtener los datos del pastel del JSON recibido + String textoEncima = jsonObject.get("textoEncima").getAsString(); + String textoCantidad = jsonObject.get("textoCantidad").getAsString(); + String textoRelleno = jsonObject.get("textoRelleno").getAsString(); + String textoTipo = jsonObject.get("textoTipo").getAsString(); + String textoPrecio = jsonObject.get("textoPrecio").getAsString(); + String textoId = jsonObject.get("idPastel").getAsString(); + + System.out.println("tamaño: " + textoCantidad); + System.out.println("tipo: " + textoTipo); + + + // Crear un nuevo objeto Pasteles y asignar los valores recibidos + Pasteles reservacion = new Pasteles(); + reservacion.setIdPedido(UUID.randomUUID().toString()); + reservacion.setIdUsuario(idG); // Asignar el ID del usuario (¿De dónde obtienes idG?) + reservacion.setIdPastel(textoId); // Asignar el ID del pastel (¿De dónde obtienes este valor?) + reservacion.setIdNombre(textoTipo); // Asignar el nombre recibido desde el frontend + reservacion.setIdPrecio(textoPrecio); // Asignar el precio del pastel (¿De dónde obtienes este valor?) + reservacion.setIdTamaño(textoCantidad); // Asignar el tamaño recibido desde el frontend + reservacion.setStatus("en proceso"); // Asignar el estado "en proceso" + reservacion.setInscripcion(textoEncima); // Asignar la inscripción recibida desde el frontend + reservacion.setTipoRelleno(textoRelleno); // Asignar el tipo de relleno recibido desde el frontend + + // Puedes realizar acciones adicionales con la información de la reservación + System.out.println("Reservación: " + reservacion); + + // Lógica para hacer la reservación en la base de datos + String mensaje = DAO.hacerPedido(reservacion); + + // Crear la respuesta + JsonObject respuesta = new JsonObject(); + respuesta.addProperty("msj", mensaje); + + return gson.toJson(respuesta); + } catch (JsonSyntaxException e) { + // Manejar errores de formato JSON + System.out.println("Error en el formato JSON: " + e.getMessage()); + response.status(400); // Bad Request + return gson.toJson("Error en el formato JSON"); + } catch (Exception e) { + // Manejar otros errores + System.out.println("Error en la reservación: " + e.getMessage()); + response.status(500); // Internal Server Error + return gson.toJson("Error en la reservación"); + } + }); + + post("/frontend/obtenerPedidosDePasteles", (request, response) -> { + response.type("application/json"); + + // Obtener el ID del usuario desde la variable global + String idUsuario = idG; + + // Obtener los pedidos de pasteles para el usuario + List pedidosDePasteles = DAO.damePedidosDePastelesPorUsuario(idUsuario); + + int numeroDePedidos = pedidosDePasteles.size(); + + System.out.println("Número de pedidos de pasteles: " + numeroDePedidos); + + // Construir un objeto JSON con los pedidos de pasteles + JsonArray pedidosArray = new JsonArray(); + for (Pasteles pedido : pedidosDePasteles) { + JsonObject pedidoJson = new JsonObject(); + pedidoJson.addProperty("id_pedido", pedido.getIdPedido()); + pedidoJson.addProperty("id_usuario", pedido.getIdUsuario()); + pedidoJson.addProperty("id_pastel", pedido.getIdPastel()); + pedidoJson.addProperty("nombre_pastel", pedido.getIdNombre()); + pedidoJson.addProperty("precio", pedido.getIdPrecio()); + pedidoJson.addProperty("tamaño", pedido.getIdTamaño()); + pedidoJson.addProperty("estatus", pedido.getStatus()); + pedidoJson.addProperty("inscripcion", pedido.getInscripcion()); + pedidoJson.addProperty("relleno", pedido.getTipoRelleno()); + pedidosArray.add(pedidoJson); + } + + // Crear el objeto final que contiene todos los pedidos de pasteles + JsonObject responseJson = new JsonObject(); + responseJson.add("pedidos_de_pasteles", pedidosArray); + + System.out.println(responseJson); + return responseJson.toString(); + }); + + post("/frontend/eliminarPedido", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + String idPedido = jsonObject.get("datosId").getAsJsonObject().get("idPedido").getAsString(); + + // Lógica para eliminar el pedido usando el ID + boolean eliminado = DAO.eliminarPedido(idPedido); + + JsonObject respuesta = new JsonObject(); + if (eliminado) { + respuesta.addProperty("msj", "Pedido eliminado exitosamente."); + } else { + respuesta.addProperty("msj", "No se encontró ningún pedido con el ID especificado."); + } + + return respuesta.toString(); + }); + + post("/frontend/actualizarEstatusPedido", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + String idPedido = jsonObject.get("datosId").getAsJsonObject().get("idPedido").getAsString(); + String nuevoEstatus = jsonObject.get("datosId").getAsJsonObject().get("nuevoEstatus").getAsString(); + + // Lógica para actualizar el estatus del pedido usando el ID + boolean actualizado = DAO.actualizarEstatusPedido(idPedido, nuevoEstatus); + + JsonObject respuesta = new JsonObject(); + if (actualizado) { + respuesta.addProperty("msj", "Pedido actualizado exitosamente."); + } else { + respuesta.addProperty("msj", "No se encontró ningún pedido con el ID especificado."); + } + + return respuesta.toString(); + }); + + + post("/frontend/obtenerPedidosDePastelesAdmin", (request, response) -> { + response.type("application/json"); + + // Obtener todos los pedidos de pasteles + List pedidosDePasteles = DAO.dameTodosLosPedidosDePasteles2(); + + int numeroDePedidos = pedidosDePasteles.size(); + + System.out.println("Número de pedidos de pasteles: " + numeroDePedidos); + + // Construir un objeto JSON con los pedidos de pasteles + JsonArray pedidosArray = new JsonArray(); + for (Pasteles pedido : pedidosDePasteles) { + JsonObject pedidoJson = new JsonObject(); + pedidoJson.addProperty("id_pedido", pedido.getIdPedido()); + pedidoJson.addProperty("id_usuario", pedido.getIdUsuario()); + pedidoJson.addProperty("id_pastel", pedido.getIdPastel()); + pedidoJson.addProperty("nombre_pastel", pedido.getIdNombre()); + pedidoJson.addProperty("precio", pedido.getIdPrecio()); + pedidoJson.addProperty("tamaño", pedido.getIdTamaño()); + pedidoJson.addProperty("estatus", pedido.getStatus()); + pedidoJson.addProperty("inscripcion", pedido.getInscripcion()); + pedidoJson.addProperty("relleno", pedido.getTipoRelleno()); + pedidosArray.add(pedidoJson); + } + + // Crear el objeto final que contiene todos los pedidos de pasteles + JsonObject responseJson = new JsonObject(); + responseJson.add("pedidos_de_pasteles", pedidosArray); + + System.out.println(responseJson); + return responseJson.toString(); + }); + + post("/frontend/agregarResenia", (request, response) -> { + response.type("application/json"); + String payload = request.body(); + + try { + JsonElement jsonElement = JsonParser.parseString(payload); + JsonObject jsonObject = jsonElement.getAsJsonObject(); + + // Obtener los datos de la reseña del JSON recibido + String nombreUsuario = jsonObject.get("nombreUsuario").getAsString(); + String idPastel = jsonObject.get("idPastel").getAsString(); + String contenido = jsonObject.get("contenido").getAsString(); + int estrellas = jsonObject.get("estrellas").getAsInt(); + + // Crear un nuevo objeto Reseñas y asignar los valores recibidos + Reseñas reseña = new Reseñas(); + reseña.setIdReseña(UUID.randomUUID().toString()); + reseña.setNombreUsuario(nombreUsuario); + reseña.setIdPastel(idPastel); + reseña.setContenido(contenido); + reseña.setEstrellas(estrellas); + + // Puedes realizar acciones adicionales con la información de la reseña + System.out.println("Reseña: " + reseña); + + // Lógica para agregar la reseña en la base de datos + String mensaje = DAO.agregarReseña(reseña); + + // Crear la respuesta + JsonObject respuesta = new JsonObject(); + respuesta.addProperty("msj", mensaje); + + return gson.toJson(respuesta); + } catch (JsonSyntaxException e) { + // Manejar errores de formato JSON + System.out.println("Error en el formato JSON: " + e.getMessage()); + response.status(400); // Bad Request + return gson.toJson("Error en el formato JSON"); + } catch (Exception e) { + // Manejar otros errores + System.out.println("Error al agregar la reseña: " + e.getMessage()); + response.status(500); // Internal Server Error + return gson.toJson("Error al agregar la reseña"); + } + }); + + + post("/frontend/obtenerReseniasPorPastel", (request, response) -> { + response.type("application/json"); + + // Obtener el ID del pastel desde el cuerpo de la solicitud + JsonObject requestBody = new Gson().fromJson(request.body(), JsonObject.class); + String idPastel = requestBody.get("idPastel").getAsString(); + + // Obtener las reseñas para el pastel + List reseñas = DAO.obtenerReseñasPorPastel(idPastel); + + System.out.println("ID del pastel"+idPastel); + + int numeroDeReseñas = reseñas.size(); + + System.out.println("Número de reseñas: " + numeroDeReseñas); + + // Construir un objeto JSON con las reseñas + JsonArray reseñasArray = new JsonArray(); + for (Reseñas reseña : reseñas) { + JsonObject reseñaJson = new JsonObject(); + reseñaJson.addProperty("id_reseña", reseña.getIdReseña()); + reseñaJson.addProperty("nombre_usuario", reseña.getNombreUsuario()); + reseñaJson.addProperty("id_pastel", reseña.getIdPastel()); + reseñaJson.addProperty("contenido", reseña.getContenido()); + reseñaJson.addProperty("estrellas", reseña.getEstrellas()); + reseñasArray.add(reseñaJson); + } + + // Crear el objeto final que contiene todas las reseñas + JsonObject responseJson = new JsonObject(); + responseJson.add("reseñas", reseñasArray); + + System.out.println(responseJson); + return responseJson.toString(); + }); + + + + + + + + + + + } + + + + static int getHerokuAssignedPort() { + ProcessBuilder processBuilder = new ProcessBuilder(); + if (processBuilder.environment().get("PORT") != null) { + return Integer.parseInt(processBuilder.environment().get("PORT")); + } + return 4567; //return default port if heroku-port isn't set (i.e. on localhost) + } +} \ No newline at end of file diff --git a/backend/src/main/java/mx/uv/Conexion.java b/backend/src/main/java/mx/uv/Conexion.java new file mode 100644 index 0000000..08228ce --- /dev/null +++ b/backend/src/main/java/mx/uv/Conexion.java @@ -0,0 +1,28 @@ +package mx.uv; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; + +public class Conexion { + private static String url = "jdbc:mysql://127.0.0.1:3306/dbpastel00"; + private static String driverName = "com.mysql.cj.jdbc.Driver"; + private static String username = "pastel00"; + private static String password = "pastel00"; + // variable de conexion + private static Connection connection = null; + + public static Connection getConnection(){ + try { + Class.forName(driverName); + connection = DriverManager.getConnection(url, username, password); + System.out.println("conexion exitosa"); + } catch (SQLException e) { + System.out.println(" SQL:" + e); + } catch (ClassNotFoundException e){ + System.out.println("Driver:" + e); + } + + return connection; + } +} \ No newline at end of file diff --git a/backend/src/main/java/mx/uv/DAO.java b/backend/src/main/java/mx/uv/DAO.java new file mode 100644 index 0000000..5492ceb --- /dev/null +++ b/backend/src/main/java/mx/uv/DAO.java @@ -0,0 +1,620 @@ +package mx.uv; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.Statement; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +// Data Access Object +public class DAO { + // en el dao se establece la conexion a la BD + private static Conexion c = new Conexion(); + // este metodo regresa un conjunto de usuarios que cumpla un criterio + public static List dameUsuarios() { + Statement stm = null; + ResultSet rs = null; + Connection conn = null; + + List resultado = new ArrayList<>(); + + conn = Conexion.getConnection(); + + try { + String sql = "SELECT * from usuarios"; + stm = (Statement) conn.createStatement(); + rs = stm.executeQuery(sql); + while (rs.next()) { + Usuario u = new Usuario(rs.getString("id"), rs.getString("correo"), rs.getString("password"), rs.getString("nombre")); + resultado.add(u); + } + } catch (Exception e) { + System.out.println(e); + } finally { + if (rs != null) + try { + rs.close(); + } catch (SQLException e) { + System.out.println(e); + } + rs = null; + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + stm = null; + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + + return resultado; + } + + public static String crearUsuario(Usuario u) { + PreparedStatement stm = null; + Connection conn = null; + String msj = ""; + + conn = Conexion.getConnection(); + try { + String sql = "INSERT INTO usuarios (id, correo, password,nombre) values (?,?,?,?)"; + stm = (PreparedStatement) conn.prepareStatement(sql); + stm.setString(1, u.getId()); + stm.setString(2, u.getCorreo()); + stm.setString(3, u.getPassword()); + stm.setString(4, u.getNombre()); + if (stm.executeUpdate() > 0) + msj = "usuario agregado"; + else + msj = "usuario no agregado"; + + } catch (Exception e) { + System.out.println(e); + } finally { + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + stm = null; + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + return msj; + } + + public static boolean validarUsuario(String correo, String password) { + PreparedStatement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + try { + String sql = "SELECT * FROM usuarios WHERE correo = ? AND password = ?"; + stm = conn.prepareStatement(sql); + stm.setString(1, correo); + stm.setString(2, password); + + ResultSet rs = stm.executeQuery(); + + return rs.next(); // Devuelve true si hay una coincidencia, false si no hay coincidencia + + } catch (Exception e) { + System.out.println(e); + return false; // Manejar adecuadamente las excepciones en tu aplicación real + } finally { + // Cerrar recursos + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + } + + public static boolean correoExistente(String correo) { + PreparedStatement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + try { + String sql = "SELECT * FROM usuarios WHERE correo = ?"; + stm = conn.prepareStatement(sql); + stm.setString(1, correo); + + ResultSet rs = stm.executeQuery(); + + return rs.next(); // Devuelve true si hay una coincidencia (correo existente), false si no hay coincidencia + + } catch (Exception e) { + System.out.println(e); + return false; // Manejar adecuadamente las excepciones en tu aplicación real + } finally { + // Cerrar recursos + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + } + + public static boolean existeUsuarioPorCorreo(String correo) { + PreparedStatement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + try { + String sql = "SELECT COUNT(*) as num_usuarios FROM usuarios WHERE correo = ?"; + stm = conn.prepareStatement(sql); + stm.setString(1, correo); + + ResultSet rs = stm.executeQuery(); + + if (rs.next()) { + return rs.getInt("num_usuarios") > 0; // Devuelve true si existe al menos un usuario con ese correo + } else { + return false; // Devuelve false si no hay usuarios con ese correo + } + + } catch (Exception e) { + System.out.println(e); + return false; // Manejar adecuadamente las excepciones en tu aplicación real + } finally { + // Cerrar recursos + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + } + + public static String cambiarContrasena(String correo, String nuevaContrasena) { + String mensaje = ""; + + try (Connection conn = Conexion.getConnection(); + PreparedStatement stm = conn.prepareStatement("UPDATE usuarios SET password = ? WHERE correo = ?")) { + + // Verificar si el usuario existe + if (existeUsuarioPorCorreo(correo)) { + stm.setString(1, nuevaContrasena); + stm.setString(2, correo); + + if (stm.executeUpdate() > 0) { + mensaje = "Contraseña actualizada correctamente"; + } else { + mensaje = "No se pudo actualizar la contraseña"; + } + } else { + mensaje = "Usuario no encontrado"; + } + + } catch (SQLException e) { + // Manejo de excepciones (puedes personalizar este manejo según tus necesidades) + mensaje = "Error al actualizar la contraseña"; + e.printStackTrace(); // O registra la excepción en un sistema de registro + } + + return mensaje; + } + + public static String obtenerIdUsuario(String correo, String password) { + PreparedStatement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + try { + String sql = "SELECT id FROM usuarios WHERE correo = ? AND password = ?"; + stm = conn.prepareStatement(sql); + stm.setString(1, correo); + stm.setString(2, password); + + ResultSet rs = stm.executeQuery(); + + if (rs.next()) { + return rs.getString("id"); // Devuelve el ID si hay una coincidencia + } else { + return "falso"; // Devuelve -1 si no hay coincidencia + } + + } catch (Exception e) { + System.out.println(e); + return "falso"; // Manejar adecuadamente las excepciones en tu aplicación real + } finally { + // Cerrar recursos + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + } + + + + public static Usuario obtenerDatosUsuario(String id) { + PreparedStatement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + try { + String sql = "SELECT * FROM usuarios WHERE id = ?"; + stm = conn.prepareStatement(sql); + stm.setString(1, id); + + ResultSet rs = stm.executeQuery(); + + if (rs.next()) { + // Crear un objeto Usuario con los datos del usuario + Usuario usuario = new Usuario(); + usuario.setId(rs.getString("id")); + usuario.setCorreo(rs.getString("correo")); + usuario.setPassword(rs.getString("password")); + usuario.setNombre(rs.getString("nombre")); + // Agregar más campos según tu estructura de base de datos + + return usuario; + } else { + return null; // Devuelve null si no hay coincidencia + } + + } catch (Exception e) { + System.out.println(e); + return null; // Manejar adecuadamente las excepciones en tu aplicación real + } finally { + // Cerrar recursos + if (stm != null) { + try { + stm.close(); + } catch (Exception e) { + System.out.println(e); + } + } + try { + conn.close(); + } catch (Exception e) { + System.out.println(e); + } + } + } + + + + public static String hacerPedido(Pasteles pasteles) { + PreparedStatement stm = null; + Connection conn = null; + String mensaje = ""; + + conn = Conexion.getConnection(); + try { + String sql = "INSERT INTO pedidos (idUsuario, idPastel, precio, tamaño, estatus, inscripcion, relleno) VALUES (?,?,?,?,?,?,?)"; + stm = conn.prepareStatement(sql); + stm.setString(1, pasteles.getIdUsuario()); + stm.setString(2, pasteles.getIdPastel()); + stm.setString(3, pasteles.getIdPrecio()); + stm.setString(4, pasteles.getIdTamaño()); + stm.setString(5, pasteles.getStatus()); + stm.setString(6, pasteles.getInscripcion()); + stm.setString(7, pasteles.getTipoRelleno()); + + if (stm.executeUpdate() > 0) + mensaje = "Pedido realizado con éxito"; + else + mensaje = "No se pudo realizar el pedido"; + + } catch (SQLException e) { + System.out.println("Error al ejecutar la consulta: " + e.getMessage()); + } finally { + if (stm != null) { + try { + stm.close(); + } catch (SQLException e) { + System.out.println("Error al cerrar el statement: " + e.getMessage()); + } + } + if (conn != null) { + try { + conn.close(); + } catch (SQLException e) { + System.out.println("Error al cerrar la conexión: " + e.getMessage()); + } + } + } + return mensaje; + } + + public static List damePedidosDePastelesPorUsuario(String idUsuario) { + System.out.println("ENTRO AL METODO: damePedidosDePastelesPorUsuario"); + Connection conn = null; + PreparedStatement pstmt = null; + ResultSet rs = null; + List resultado = new ArrayList<>(); + + try { + conn = Conexion.getConnection(); + String sql = "SELECT p.idPedido, p.idUsuario, p.idPastel, pastel.nombreP as nombre_pastel, pastel.precio, " + + "p.tamaño, p.estatus, p.inscripcion, p.relleno " + + "FROM pedidos p " + + "JOIN pasteles pastel ON p.idPastel = pastel.id " + + "WHERE p.idUsuario = ?"; + pstmt = conn.prepareStatement(sql); + pstmt.setString(1, idUsuario); + rs = pstmt.executeQuery(); + while (rs.next()) { + Pasteles pastel = new Pasteles( + rs.getString("idPedido"), + rs.getString("idUsuario"), + rs.getString("idPastel"), + rs.getString("nombre_pastel"), + rs.getString("precio"), + rs.getString("tamaño"), + rs.getString("estatus"), + rs.getString("inscripcion"), + rs.getString("relleno") + ); + resultado.add(pastel); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + try { + if (rs != null) rs.close(); + if (pstmt != null) pstmt.close(); + if (conn != null) conn.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + return resultado; + +} + +public static List dameTodosLosPedidosDePasteles2() { + System.out.println("ENTRO AL METODO: dameTodosLosPedidosDePasteles"); + Connection conn = null; + PreparedStatement pstmt = null; + ResultSet rs = null; + List resultado = new ArrayList<>(); + + try { + conn = Conexion.getConnection(); + String sql = "SELECT p.idPedido, p.idUsuario, p.idPastel, pastel.nombreP as nombre_pastel, pastel.precio, " + + "p.tamaño, p.estatus, p.inscripcion, p.relleno " + + "FROM pedidos p " + + "JOIN pasteles pastel ON p.idPastel = pastel.id"; + pstmt = conn.prepareStatement(sql); + rs = pstmt.executeQuery(); + while (rs.next()) { + Pasteles pastel = new Pasteles( + rs.getString("idPedido"), + rs.getString("idUsuario"), + rs.getString("idPastel"), + rs.getString("nombre_pastel"), + rs.getString("precio"), + rs.getString("tamaño"), + rs.getString("estatus"), + rs.getString("inscripcion"), + rs.getString("relleno") + ); + resultado.add(pastel); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + try { + if (rs != null) rs.close(); + if (pstmt != null) pstmt.close(); + if (conn != null) conn.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + return resultado; +} + +public static String agregarReseña(Reseñas reseña) { + PreparedStatement stm = null; + Connection conn = null; + String mensaje = ""; + + conn = Conexion.getConnection(); + try { + String sql = "INSERT INTO reseñas (nombreUsuario, idPastel, contenido, estrellas) VALUES (?,?,?,?)"; + stm = conn.prepareStatement(sql); + stm.setString(1, reseña.getNombreUsuario()); + stm.setString(2, reseña.getIdPastel()); + stm.setString(3, reseña.getContenido()); + stm.setInt(4, reseña.getEstrellas()); + + if (stm.executeUpdate() > 0) + mensaje = "Reseña agregada con éxito"; + else + mensaje = "No se pudo agregar la reseña"; + + } catch (SQLException e) { + System.out.println("Error al ejecutar la consulta: " + e.getMessage()); + } finally { + if (stm != null) { + try { + stm.close(); + } catch (SQLException e) { + System.out.println("Error al cerrar el statement: " + e.getMessage()); + } + } + if (conn != null) { + try { + conn.close(); + } catch (SQLException e) { + System.out.println("Error al cerrar la conexión: " + e.getMessage()); + } + } + } + return mensaje; +} + +public static List obtenerReseñasPorPastel(String idPastel) { + Connection conn = null; + PreparedStatement pstmt = null; + ResultSet rs = null; + List resultado = new ArrayList<>(); + + try { + conn = Conexion.getConnection(); + String sql = "SELECT r.idReseña, r.nombreUsuario, r.idPastel, r.contenido, r.estrellas " + + "FROM reseñas r " + + "WHERE r.idPastel = ?"; + pstmt = conn.prepareStatement(sql); + pstmt.setString(1, idPastel); + rs = pstmt.executeQuery(); + while (rs.next()) { + Reseñas reseña = new Reseñas( + rs.getString("idReseña"), + rs.getString("nombreUsuario"), + rs.getString("idPastel"), + rs.getString("contenido"), + rs.getInt("estrellas") + ); + resultado.add(reseña); + } + } catch (SQLException e) { + e.printStackTrace(); + } finally { + try { + if (rs != null) rs.close(); + if (pstmt != null) pstmt.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + return resultado; +} + + +public static boolean eliminarPedido(String idPedido) { + System.out.println("ENTRO AL METODO: eliminarPedido"); + Statement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + + try { + String sql = "DELETE FROM pedidos WHERE idPedido = '" + idPedido + "'"; + stm = (Statement) conn.createStatement(); + int filasAfectadas = stm.executeUpdate(sql); + + // Verificamos si se eliminó alguna fila + if (filasAfectadas > 0) { + System.out.println("Pedido eliminado exitosamente."); + return true; + } else { + System.out.println("No se encontró ningún pedido con el ID especificado."); + return false; + } + } catch (SQLException e) { + System.out.println("Error al eliminar el pedido: " + e); + } finally { + // Cierre de recursos + if (stm != null) { + try { + stm.close(); + } catch (SQLException e) { + System.out.println(e); + } + } + } + + return false; +} + + +public static boolean actualizarEstatusPedido(String idPedido, String nuevoEstatus) { + System.out.println("ENTRO AL METODO: actualizarEstatusPedido"); + Statement stm = null; + Connection conn = null; + + conn = Conexion.getConnection(); + + try { + String sql = "UPDATE pedidos SET estatus = '" + nuevoEstatus + "' WHERE idPedido = '" + idPedido + "'"; + stm = (Statement) conn.createStatement(); + int filasAfectadas = stm.executeUpdate(sql); + + // Verificamos si se actualizó alguna fila + if (filasAfectadas > 0) { + System.out.println("Pedido actualizado exitosamente."); + return true; + } else { + System.out.println("No se encontró ningún pedido con el ID especificado."); + return false; + } + } catch (SQLException e) { + System.out.println("Error al actualizar el pedido: " + e); + } finally { + // Cierre de recursos + if (stm != null) { + try { + stm.close(); + } catch (SQLException e) { + System.out.println(e); + } + } + try { + conn.close(); + } catch (SQLException e) { + System.out.println(e); + } + } + + return false; +} + + + + + + +} \ No newline at end of file diff --git a/backend/src/main/java/mx/uv/Pasteles.java b/backend/src/main/java/mx/uv/Pasteles.java new file mode 100644 index 0000000..c486690 --- /dev/null +++ b/backend/src/main/java/mx/uv/Pasteles.java @@ -0,0 +1,112 @@ +package mx.uv; + +public class Pasteles { + + String idPedido; + String idUsuario; + String idPastel; + String idNombre; + String idPrecio; + String idTamaño; + String status; + String inscripcion; + String tipoRelleno; + + public String getIdPedido() { + return idPedido; + } + + public void setIdPedido(String idPedido) { + this.idPedido = idPedido; + } + + public String getIdUsuario() { + return idUsuario; + } + + public void setIdUsuario(String idUsuario) { + this.idUsuario = idUsuario; + } + + public String getIdPastel() { + return idPastel; + } + + public void setIdPastel(String idPastel) { + this.idPastel = idPastel; + } + + public String getIdNombre() { + return idNombre; + } + + public void setIdNombre(String idNombre) { + this.idNombre = idNombre; + } + + public String getIdPrecio() { + return idPrecio; + } + + public void setIdPrecio(String idPrecio) { + this.idPrecio = idPrecio; + } + + public String getIdTamaño() { + return idTamaño; + } + + public void setIdTamaño(String idTamaño) { + this.idTamaño = idTamaño; + } + + public String getStatus() { + return status; + } + + public void setStatus(String status) { + this.status = status; + } + + public String getInscripcion() { + return inscripcion; + } + + public void setInscripcion(String inscripcion) { + this.inscripcion = inscripcion; + } + + public String getTipoRelleno() { + return tipoRelleno; + } + + public void setTipoRelleno(String tipoRelleno) { + this.tipoRelleno = tipoRelleno; + } + + public String toString() { + return "Pasteles [idPedido=" + idPedido + ", idUsuario=" + idUsuario + ", idPastel=" + idPastel + ", idNombre=" + idNombre + ", idPrecio=" + idPrecio + + ", idTamaño=" + idTamaño + ", status=" + status + ", inscripcion=" + inscripcion + ", tipoRelleno=" + tipoRelleno + "]"; + } + + public Pasteles(){ + + } + + public Pasteles(String idPedido, String idUsuario, String idPastel, String idNombre, String idPrecio, String idTamaño, + String status, String inscripcion, String tipoRelleno) { + this.idPedido = idPedido; + this.idUsuario = idUsuario; + this.idPastel = idPastel; + this.idNombre = idNombre; + this.idPrecio = idPrecio; + this.idTamaño = idTamaño; + this.status = status; + this.inscripcion = inscripcion; + this.tipoRelleno = tipoRelleno; + } + + +} + + diff --git a/backend/src/main/java/mx/uv/Reseñas.java b/backend/src/main/java/mx/uv/Reseñas.java new file mode 100644 index 0000000..11e98c1 --- /dev/null +++ b/backend/src/main/java/mx/uv/Reseñas.java @@ -0,0 +1,67 @@ +package mx.uv; + +public class Reseñas { + + String idReseña; + String nombreUsuario; + String idPastel; + String contenido; + int estrellas; + + public String getIdReseña() { + return idReseña; + } + + public void setIdReseña(String idReseña) { + this.idReseña = idReseña; + } + + public String getNombreUsuario() { + return nombreUsuario; + } + + public void setNombreUsuario(String nombreUsuario) { + this.nombreUsuario = nombreUsuario; + } + + public String getIdPastel() { + return idPastel; + } + + public void setIdPastel(String idPastel) { + this.idPastel = idPastel; + } + + public String getContenido() { + return contenido; + } + + public void setContenido(String contenido) { + this.contenido = contenido; + } + + public int getEstrellas() { + return estrellas; + } + + public void setEstrellas(int estrellas) { + this.estrellas = estrellas; + } + + public String toString() { + return "Reseñas [idReseña=" + idReseña + ", nombreUsuario=" + nombreUsuario + ", idPastel=" + idPastel + ", contenido=" + contenido + ", estrellas=" + estrellas + "]"; + } + + public Reseñas(){ + + } + + public Reseñas(String idReseña, String nombreUsuario, String idPastel, String contenido, int estrellas) { + this.idReseña = idReseña; + this.nombreUsuario = nombreUsuario; + this.idPastel = idPastel; + this.contenido = contenido; + this.estrellas = estrellas; + } +} + diff --git a/backend/src/main/java/mx/uv/Usuario.java b/backend/src/main/java/mx/uv/Usuario.java new file mode 100644 index 0000000..0f56621 --- /dev/null +++ b/backend/src/main/java/mx/uv/Usuario.java @@ -0,0 +1,57 @@ +package mx.uv; + +public class Usuario { + String id; + String correo; + String password; + String nombre; + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getCorreo() { + return correo; + } + + public void setCorreo(String correo) { + this.correo = correo; + } + + public String getPassword() { + return password; + } + + public void setPassword(String password) { + this.password = password; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public String toString() { + return "Usuario [id=" + id + ", correo=" + correo + ", password=" + password + ", nombre=" + nombre +"]"; + } + + public Usuario(){ + + } + + public Usuario(String id, String correo, String password, String nombre) { + this.id = id; + this.correo = correo; + this.password = password; + this.nombre = nombre; + } + +} \ No newline at end of file diff --git a/backend/src/test/java/mx/uv/AppTest.java b/backend/src/test/java/mx/uv/AppTest.java new file mode 100644 index 0000000..6284b29 --- /dev/null +++ b/backend/src/test/java/mx/uv/AppTest.java @@ -0,0 +1,20 @@ +package mx.uv; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +/** + * Unit test for simple App. + */ +public class AppTest +{ + /** + * Rigorous Test :-) + */ + @Test + public void shouldAnswerWithTrue() + { + assertTrue( true ); + } +} diff --git a/backend/target/classes/mx/uv/App.class b/backend/target/classes/mx/uv/App.class new file mode 100644 index 0000000..b7bd879 Binary files /dev/null and b/backend/target/classes/mx/uv/App.class differ diff --git a/backend/target/classes/mx/uv/Conexion.class b/backend/target/classes/mx/uv/Conexion.class new file mode 100644 index 0000000..ab0f611 Binary files /dev/null and b/backend/target/classes/mx/uv/Conexion.class differ diff --git a/backend/target/classes/mx/uv/DAO.class b/backend/target/classes/mx/uv/DAO.class new file mode 100644 index 0000000..24ef473 Binary files /dev/null and b/backend/target/classes/mx/uv/DAO.class differ diff --git a/backend/target/classes/mx/uv/Pasteles.class b/backend/target/classes/mx/uv/Pasteles.class new file mode 100644 index 0000000..949eadf Binary files /dev/null and b/backend/target/classes/mx/uv/Pasteles.class differ diff --git a/backend/target/classes/mx/uv/Reseñas.class b/backend/target/classes/mx/uv/Reseñas.class new file mode 100644 index 0000000..a115abc Binary files /dev/null and b/backend/target/classes/mx/uv/Reseñas.class differ diff --git a/backend/target/classes/mx/uv/Usuario.class b/backend/target/classes/mx/uv/Usuario.class new file mode 100644 index 0000000..8187895 Binary files /dev/null and b/backend/target/classes/mx/uv/Usuario.class differ diff --git a/backend/target/test-classes/mx/uv/AppTest.class b/backend/target/test-classes/mx/uv/AppTest.class new file mode 100644 index 0000000..bb59e9b Binary files /dev/null and b/backend/target/test-classes/mx/uv/AppTest.class differ