From 2f861d3546fa0665a17491bac6f272c5a093f6ec Mon Sep 17 00:00:00 2001 From: NataliaCancinoV Date: Sat, 25 May 2024 16:24:00 -0600 Subject: [PATCH] Backend --- .vscode/settings.json | 3 + backend/pom.xml | 90 +++ backend/src/main/java/mx/uv/App.java | 630 ++++++++++++++++++ backend/src/main/java/mx/uv/Conexion.java | 28 + backend/src/main/java/mx/uv/DAO.java | 620 +++++++++++++++++ backend/src/main/java/mx/uv/Pasteles.java | 112 ++++ backend/src/main/java/mx/uv/Reseñas.java | 67 ++ backend/src/main/java/mx/uv/Usuario.java | 57 ++ backend/src/test/java/mx/uv/AppTest.java | 20 + backend/target/classes/mx/uv/App.class | Bin 0 -> 18395 bytes backend/target/classes/mx/uv/Conexion.class | Bin 0 -> 1565 bytes backend/target/classes/mx/uv/DAO.class | Bin 0 -> 18648 bytes backend/target/classes/mx/uv/Pasteles.class | Bin 0 -> 2993 bytes backend/target/classes/mx/uv/Reseñas.class | Bin 0 -> 1990 bytes backend/target/classes/mx/uv/Usuario.class | Bin 0 -> 1612 bytes .../target/test-classes/mx/uv/AppTest.class | Bin 0 -> 457 bytes 16 files changed, 1627 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 backend/pom.xml create mode 100644 backend/src/main/java/mx/uv/App.java create mode 100644 backend/src/main/java/mx/uv/Conexion.java create mode 100644 backend/src/main/java/mx/uv/DAO.java create mode 100644 backend/src/main/java/mx/uv/Pasteles.java create mode 100644 backend/src/main/java/mx/uv/Reseñas.java create mode 100644 backend/src/main/java/mx/uv/Usuario.java create mode 100644 backend/src/test/java/mx/uv/AppTest.java create mode 100644 backend/target/classes/mx/uv/App.class create mode 100644 backend/target/classes/mx/uv/Conexion.class create mode 100644 backend/target/classes/mx/uv/DAO.class create mode 100644 backend/target/classes/mx/uv/Pasteles.class create mode 100644 backend/target/classes/mx/uv/Reseñas.class create mode 100644 backend/target/classes/mx/uv/Usuario.class create mode 100644 backend/target/test-classes/mx/uv/AppTest.class 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 0000000000000000000000000000000000000000..b7bd8796d6cc6465780cda6e3a106c53b8fd0732 GIT binary patch literal 18395 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 literal 0 HcmV?d00001 diff --git a/backend/target/classes/mx/uv/Conexion.class b/backend/target/classes/mx/uv/Conexion.class new file mode 100644 index 0000000000000000000000000000000000000000..ab0f6110d0df40ee52e705581645d53ce01177fd GIT binary patch literal 1565 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 F_!qEUS=0ak literal 0 HcmV?d00001