ligação back end consumo agua

backend/src/controllers/aguaController.ts

@@ -0,0 +1,203 @@
+import { Request, Response } from "express";
+import Data from "../models/mongo/Data"; // Importando o modelo Data
+import User from "../models/mongo/User"; // Importando o modelo User
+import pg from '../databases/postgres';
+import moment from 'moment';
+
+class AguaController {
+  // Criar ou atualizar o registro de ingestão de água ou bebida para um usuário
+  async createWater(req: Request, res: Response): Promise<Response> {
+    try {
+      const { userId } = req.params; // ID do usuário deve ser passado nos parâmetros da rota
+      const { date, quantity } = req.body; // quantity e date são enviados no corpo da requisição
+
+      // Formata a data recebida
+      const formattedDate = moment(date).format("YYYY-MM-DD");
+      console.log("RECEBIDO!", formattedDate, userId);
+
+      // Verifica se o usuário existe no PostgreSQL
+      const users = await pg.query(`SELECT * FROM "User" WHERE "idUsuario" = $1`, [userId]);
+      if (users.rows.length === 0) {
+        return res.status(404).json({ message: "Usuário não encontrado" });
+      }
+
+      // Verifica se já existe um registro para o usuário na coleção Data
+      let userData = await Data.findOne({ usuario: userId, data_atual: formattedDate });
+
+      if (!userData) {
+        // Se não existir, cria um novo registro
+        userData = new Data({
+          usuario: userId,
+          data_atual: formattedDate,
+          agua: {
+            ingestaoIdeal: 2000, // Valor padrão de ingestão ideal de água
+            ingestaoAtual: quantity,
+          },
+        });
+      } else {
+        // Se existir, atualiza a ingestão atual de água
+        userData.agua.ingestaoAtual += quantity;
+      }
+
+      // Salva o documento atualizado ou criado no MongoDB
+      await userData.save();
+
+      return res.status(201).json({
+        message: "Ingestão de água atualizada com sucesso",
+        data: userData,
+      });
+    } catch (error: any) {
+      console.error("Erro ao registrar ingestão de água:", error.message);
+      return res.status(500).json({
+        message: "Erro ao registrar ingestão de água",
+        error: error.message,
+      });
+    }
+  }
+
+  // Método para buscar a ingestão de água de um usuário por data
+  async getWaterIntake(req: Request, res: Response): Promise<Response> {
+    try {
+      const { userId } = req.params; // userId e data recebidos nos parâmetros da rota
+
+      // Formata a data recebida
+      const { date } = req.body;
+      const formattedDate = moment(date).format("YYYY-MM-DD");
+
+      // Verifica se o usuário existe no PostgreSQL
+      const users = await pg.query(`SELECT * FROM "User" WHERE "idUsuario" = $1`, [userId]);
+      if (users.rows.length === 0) {
+        return res.status(404).json({ message: "Usuário não encontrado" });
+      }
+
+      console.log(date, userId)
+
+      // Busca o registro de ingestão de água no MongoDB
+      const userData = await Data.findOne({ usuario: userId, data_atual: formattedDate });
+
+      if (!userData) {
+        return res.status(404).json({ message: "Registro de ingestão de água não encontrado" });
+      }
+
+      return res.status(200).json({
+        message: "Ingestão de água encontrada",
+        data: userData.agua,
+      });
+    } catch (error: any) {
+      console.error("Erro ao buscar ingestão de água:", error.message);
+      return res.status(500).json({
+        message: "Erro ao buscar ingestão de água",
+        error: error.message,
+      });
+    }
+  }
+
+  // Atualizar registro de ingestão de bebida (água ou outra)
+  async updateWater(req: Request, res: Response): Promise<Response> {
+    try {
+      const { dataId } = req.params; // ID do registro de ingestão de bebida
+      const { quantity } = req.body; // Nova quantidade de ingestão
+
+      // Busca o registro de ingestão no MongoDB
+      const userData = await Data.findById(dataId);
+
+      if (!userData) {
+        return res.status(404).json({ message: "Registro de ingestão não encontrado" });
+      }
+
+      // Atualiza a quantidade de ingestão
+      userData.agua.ingestaoAtual = quantity;
+
+      // Salva o documento atualizado
+      await userData.save();
+
+      return res.status(200).json({
+        message: "Ingestão de bebida atualizada com sucesso",
+        data: userData.agua,
+      });
+    } catch (error: any) {
+      console.error("Erro ao atualizar ingestão de bebida:", error.message);
+      return res.status(500).json({
+        message: "Erro ao atualizar ingestão de bebida",
+        error: error.message,
+      });
+    }
+  }
+
+  // Deletar registro de ingestão de bebida (água ou outra)
+  async deleteWater(req: Request, res: Response): Promise<Response> {
+    try {
+      const { dataId } = req.params; // ID do registro de ingestão de bebida
+
+      // Verifica se o registro existe no MongoDB
+      const userData = await Data.findByIdAndDelete(dataId);
+
+      if (!userData) {
+        return res.status(404).json({ message: "Registro de ingestão não encontrado" });
+      }
+
+      return res.status(200).json({
+        message: "Registro de ingestão de bebida deletado com sucesso",
+      });
+    } catch (error: any) {
+      console.error("Erro ao deletar ingestão de bebida:", error.message);
+      return res.status(500).json({
+        message: "Erro ao deletar ingestão de bebida",
+        error: error.message,
+      });
+    }
+  }
+
+  async aguaIncremento(req: Request, res: Response): Promise<Response> {
+    try {
+
+      const { date, quantify } = req.body;
+      const { idUser } = req.params;
+      let quantidade = parseInt(quantify)
+      console.log(date);
+      console.log(idUser);
+      const userMG = await User.find({ idUser: idUser });
+
+      if (!userMG) {
+        return res
+          .status(400)
+          .json({ message: "Erro ao buscar usuário no mongo!" });
+      }
+
+      let usuarioEncontrado: any | string;
+
+      for (const usersPG of userMG) {
+        let buscandoUsuario = await Data.findOne({
+          data_atual: date,
+          usuario: usersPG?.id,
+        });
+        if (buscandoUsuario) {
+          usuarioEncontrado = buscandoUsuario;
+        }
+      }
+
+      if (!usuarioEncontrado) {
+        return res
+          .status(400)
+          .json({ message: "Erro ao buscar usuário nessa data!" });
+      }
+
+      const userMongo = await User.findById(usuarioEncontrado.usuario);
+      if (userMongo) {
+        userMongo.ingestaoAgua.ingestaoAtual+=quantidade;
+        userMongo.save();
+        return res.status(202).json(userMongo.ingestaoAgua);
+      }
+    } catch (error: any) {
+      console.error("ERRO AO BUSCAR ALIMENTOS CONSUMIDOS:", error.message)
+      return res.status(404).json({ "ERRO": error.message });
+
+    }
+    return res.status(404).json("ERRO");
+
+  }
+}
+
+
+
+export default new AguaController();

backend/src/routes/agua.ts

@@ -0,0 +1,18 @@
+import { Router } from "express";
+import AguaController from "../controllers/aguaController";
+
+const AguaRouter = Router();
+
+// Rota para criar novo registro de ingestão de água
+AguaRouter.post("/agua/:idUser", AguaController.aguaIncremento);
+
+// Rota para buscar histórico de ingestão de água de um usuário
+AguaRouter.get("/agua/:idUser", AguaController.getWaterIntake);
+
+// Rota para atualizar registro de ingestão de água
+AguaRouter.put("/agua/:idUser", AguaController.updateWater);
+
+// Rota para deletar registro de ingestão de água
+AguaRouter.delete("/agua/:idUser", AguaController.deleteWater);
+
+export default AguaRouter;

backend/src/routes/index.ts

@@ -7,6 +7,7 @@ import DashboardRouter from "./dashboardRoutes";
 import cors from "cors";
 import express from "express";
 import LoginRouter from "./loginRoutes";
+import AguaRouter from "./agua";
 
 const router = express.Router();
 
@@ -18,5 +19,6 @@ router.use(ProfileRouter);
 router.use(CadastroRouter);
 router.use(LoginRouter);
 router.use(FoodRouter);
+router.use(AguaRouter);
 
 export default router;

frontend/src/components/AguaConsumo/index.tsx

@@ -90,8 +90,4 @@ const styles = StyleSheet.create({
     },
 
 
-});
-
-
-
-
+});

frontend/src/screens/AguaScreen/index.tsx

@@ -1,25 +1,74 @@
-import React, { useState } from "react";
+import React, { useState, useEffect } from "react";
 import { View, Text, StyleSheet, TouchableOpacity, Image, Alert } from "react-native";
 import { Ionicons } from "@expo/vector-icons";
 import styles from "./styles";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import axios from "axios";
+import { BACKEND_API_URL } from "@env";
+import { useNavigation } from '@react-navigation/native'; // Importa o hook de navegação
 
 export default function Agua() {
   const [quantity, setQuantity] = useState(150);
-  const [savedQuantity, setSavedQuantity] = useState<number | null>(null); // Estado para armazenar o valor ao pressionar OK
+  const [savedQuantity, setSavedQuantity] = useState<number | null>(null);
+  const [userId, setUserId] = useState<string | null>(null);
+  const [date, setDate] = useState<string | null>(null);
 
-  console.log(savedQuantity);
+  const MAX_QUANTITY = 1000;
+
+  const navigation = useNavigation();
 
   const decrement = () => setQuantity(quantity > 0 ? quantity - 50 : 0);
-  const increment = () => setQuantity(quantity + 50);
+  const increment = () => setQuantity(quantity < MAX_QUANTITY ? quantity + 50 : MAX_QUANTITY);
+
+  const handleSave = async () => {
+    // Check if userId and date are provided
+    if (userId && date) {
+      try {
+        // Make PUT request to update the water quantity for the user
+        const response = await axios.post(`${BACKEND_API_URL}/agua/${userId}`, {
+          date: date,
+          quantify: quantity
+        });
+        // Update the saved quantity state
+        setSavedQuantity(quantity);
+
+        // Show a success alert to the user
+        Alert.alert("Quantidade salva", `Você salvou ${quantity} ml.`, [
+          { text: "OK", onPress: () => navigation.goBack() }, // Navigate back to the previous screen
+        ]);
+      } catch (error) {
+        // Log error and show an alert if the request fails
+        console.error("Erro ao salvar a quantidade de água:", error);
+        Alert.alert("Erro", "Não foi possível salvar a quantidade de água.");
+      }
+    } else {
+      // Show an alert if userId or date is not provided
+      Alert.alert("Erro", "Usuário ou data não encontrada.");
+    }
+  };
+
+  const loadUserFromStorage = async () => {
+    try {
+      const storedUser = await AsyncStorage.getItem("user");
+      const storedDate = await AsyncStorage.getItem("date");
 
-  const handleSave = () => {
-    setSavedQuantity(quantity); // Salva o valor atual
-    Alert.alert("Quantidade salva", `Você salvou ${quantity} ml.`);
+      if (storedUser && storedDate) {
+        const user = JSON.parse(storedUser);
+        setUserId(user.id);
+        setDate(JSON.parse(storedDate));
+      }
+    } catch (error) {
+      console.error("Erro ao obter dados do AsyncStorage:", error);
+    }
   };
 
+  useEffect(() => {
+    loadUserFromStorage();
+  }, []);
+
   return (
     <View style={styles.container}>
-          <Text style={styles.title}>Selecione a quantidade de Agua</Text>
+      <Text style={styles.title}>Selecione a quantidade de Água</Text>
 
       <View style={styles.card}>
         <View style={styles.row}>
@@ -31,15 +80,12 @@ export default function Agua() {
         </View>
 
         <View style={styles.row}>
-          {/* Botão de decremento à esquerda */}
           <TouchableOpacity onPress={decrement} style={styles.circleButton}>
             <Ionicons name="remove-circle" size={30} color="red" />
           </TouchableOpacity>
 
-          {/* Texto com a quantidade */}
           <Text style={styles.quantity}>{quantity} ml</Text>
 
-          {/* Botão de incremento à direita */}
           <TouchableOpacity onPress={increment} style={styles.circleButton}>
             <Ionicons name="add-circle" size={30} color="green" />
           </TouchableOpacity>