Merge branch 'develop' into gastos

Author: anibalcontreras

.github/workflows/pytest.yml

@@ -33,6 +33,7 @@ jobs:
       - uses: pavelzw/pytest-action@v2
         env:
           SECRET_KEY: ${{ secrets.DJANGO_SECRET_KEY }}
+          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
           AWS_REGION: us-east-2
         with:
           emoji: false

AI/AI.py

@@ -1,9 +1,14 @@
+# flake8: noqa
 import openai
 import os
+from textwrap import dedent
+from dotenv import load_dotenv
 
 
 def setup_api_key():
-    openai.api_key = os.environ["OPENAI_KEY"]
+    env_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env")
+    load_dotenv(dotenv_path=env_path)
+    openai.api_key = os.getenv("OPENAI_KEY")
 
 
 def classify_text(texto):
@@ -12,21 +17,29 @@ def classify_text(texto):
         messages=[
             {
                 "role": "system",
-                "content": "Eres un modelo que clasifica gastos en \
-                categorías predefinidas.",
+                "content": dedent(
+                    """\
+                    Eres un modelo que clasifica gastos en categorías predefinidas.
+                """
+                ),
             },
             {
                 "role": "user",
-                "content": f"Clasifica el siguiente gasto en una de las \
-              categorías: comida, transporte, vivienda, educación, salud, \
-                 entretenimiento,\
-             ahorro, inversión.\n\nTexto: {texto}\n\nCategoría:",
+                "content": dedent(
+                    f"""\
+                    Clasifica el siguiente gasto en una de las categorías: comida, transporte, vivienda, educación, salud, entretenimiento, ahorro, inversión.
+
+                    Texto: {texto}
+
+                    Categoría:
+                """
+                ),
             },
         ],
         max_tokens=15,
         temperature=0,
     )
-    category = response.choices[0].message["content"].strip()
+    category = response["choices"][0]["message"]["content"].strip()
     return category
 
 

AI/tests.py

@@ -0,0 +1,63 @@
+# flake8: noqa
+import unittest
+from unittest.mock import patch
+from AI import classify_text, clean_category
+from textwrap import dedent
+
+
+class TestGastosClassifier(unittest.TestCase):
+
+    @patch("openai.ChatCompletion.create")
+    def test_classify_text(self, mock_create):
+        # Configurar el mock para devolver una respuesta simulada
+        mock_create.return_value = {"choices": [{"message": {"role": "assistant", "content": "Comida."}}]}
+
+        # Llamar a la función a probar
+        texto = "Compré una pizza."
+        categoria = classify_text(texto)
+
+        # Verificar que la respuesta sea la esperada
+        self.assertEqual(categoria, "Comida.")
+
+        # Verificar que la API fue llamada con los parámetros correctos
+        mock_create.assert_called_once_with(
+            model="gpt-4-turbo",
+            messages=[
+                {
+                    "role": "system",
+                    "content": dedent(
+                        """\
+                        Eres un modelo que clasifica gastos en categorías predefinidas.
+                    """
+                    ),
+                },
+                {
+                    "role": "user",
+                    "content": dedent(
+                        f"""\
+                        Clasifica el siguiente gasto en una de las categorías: comida, transporte, vivienda, educación, salud, entretenimiento, ahorro, inversión.
+
+                        Texto: {texto}
+
+                        Categoría:
+                    """
+                    ),
+                },
+            ],
+            max_tokens=15,
+            temperature=0,
+        )
+
+    def test_clean_category(self):
+        # Pruebas con diferentes casos
+        self.assertEqual(clean_category("Categoría: Comida."), "Comida")
+        self.assertEqual(clean_category("categoría: transporte"), "Transporte")
+        self.assertEqual(clean_category("vivienda."), "Vivienda")
+
+        # Prueba de una categoría no permitida
+        with self.assertRaises(ValueError):
+            clean_category("Categoría: Viajes.")
+
+
+if __name__ == "__main__":
+    unittest.main()

Pipfile

@@ -7,6 +7,7 @@ name = "pypi"
 django = "*"
 psycopg2-binary = "*"
 python-dotenv = "*"
+openai = "==0.28"
 djangorestframework = "*"
 boto3 = "*"
 pyjwt = "*"

Pipfile.lock

@@ -1,33 +1,31 @@
 from functools import wraps
 from rest_framework.response import Response
 from rest_framework import status
-from rest_framework.decorators import api_view, authentication_classes
+from django.contrib.auth import get_user_model
 from .services.cognito_authentication import CognitoAuthentication
+from .utils import get_user_id_from_token
+
+User = get_user_model()
 
 
 def cognito_authenticated(func):
     @wraps(func)
-    def wrapper(self, request, *args, **kwargs):
-        auth = CognitoAuthentication()
+    def wrapper(view_instance, request, *args, **kwargs):
         try:
-            result = auth.authenticate(request)
-            if result is None:
-                return Response(
-                    {"error": "Authentication credentials were not provided or are invalid."},
-                    status=status.HTTP_401_UNAUTHORIZED,
-                )
-            user, auth_error = result
-            if auth_error or not user:
+            user_id = get_user_id_from_token(request)
+            try:
+                user = User.objects.get(user_id=user_id)
+                request.user = user
+            except User.DoesNotExist:
                 return Response(
-                    {"error": "Authentication credentials were not provided or are invalid."},
+                    {"error": "Authenticated user not found."},
                     status=status.HTTP_401_UNAUTHORIZED,
                 )
-            request.user = user
-            return func(self, request, *args, **kwargs)
+            return func(view_instance, request, *args, **kwargs)
         except Exception as e:
             return Response(
                 {"error": f"Authentication failed: {str(e)}"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                status=status.HTTP_401_UNAUTHORIZED,
             )
 
     return wrapper

authentication/decorators.py

@@ -1,4 +1,11 @@
 from rest_framework import serializers
+from .models import User
+
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ["user_id", "first_name", "phone", "email"]
 
 
 class RegisterSerializer(serializers.Serializer):

authentication/serializers.py

@@ -3,6 +3,8 @@
 from rest_framework.test import APIClient
 from rest_framework import status
 from authentication.services.cognito_service import CognitoService
+from authentication.views import ProfileView
+from rest_framework.response import Response
 
 
 class RegisterViewTests(TestCase):
@@ -53,3 +55,23 @@ def test_login_user_failure(self, mock_login_user):
         response = self.client.post(self.url, self.data, format="json")
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(response.data["error"], "Login failed")
+
+
+class ProfileViewTests(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.url = "/auth/profile/"
+        self.data = {"email": "johndoe@example.com", "password": "securepassword123"}
+
+    @patch.object(ProfileView, "get")
+    @patch.object(CognitoService, "login_user")
+    def test_get(self, mock_login_user, mock_get):
+        mock_login_user.return_value = {
+            "AuthenticationResult": {"AccessToken": "mock_access_token", "IdToken": "mock_id_token"}
+        }
+        mock_get.return_value = Response(status=status.HTTP_200_OK, data={"first_name": "John Doe"})
+        request = self.client.get(self.url)
+        request.headers["Authorization"] = "Bearer mock_access_token"
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data["first_name"], "John Doe")

authentication/tests/tests.py

@@ -1,7 +1,8 @@
 from django.urls import path
-from .views import RegisterView, LoginView
+from .views import RegisterView, LoginView, ProfileView
 
 urlpatterns = [
     path("register/", RegisterView.as_view(), name="register"),
     path("login/", LoginView.as_view(), name="login"),
+    path("profile/", ProfileView.as_view(), name="profile"),
 ]

authentication/urls.py

@@ -0,0 +1,21 @@
+import jwt
+
+
+def get_user_id_from_token(request):
+    try:
+        authorization_header = request.headers.get("Authorization")
+        if not authorization_header:
+            raise Exception("Authorization header not found")
+
+        token = authorization_header.split()[1]
+        decoded_token = jwt.decode(token, options={"verify_signature": False})
+        user_id = decoded_token.get("username")
+        if not user_id:
+            raise Exception("User ID not found in token")
+        return user_id
+    except jwt.DecodeError:
+        raise Exception("Invalid token")
+    except jwt.ExpiredSignatureError:
+        raise Exception("Expired token")
+    except Exception as e:
+        raise Exception(f"Error decoding token: {e}")

authentication/utils.py

@@ -4,6 +4,9 @@
 from .serializers import RegisterSerializer, LoginSerializer
 from .services.cognito_service import CognitoService
 from django.conf import settings
+from .models import User
+from .decorators import cognito_authenticated
+import jwt
 
 
 cognito_service = CognitoService(
@@ -48,3 +51,39 @@ def post(self, request):
             except Exception as e:
                 return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+class ProfileView(APIView):
+    def get_user_id_from_token(self, request):
+        try:
+            authorization_header = request.headers.get("Authorization")
+            if not authorization_header:
+                raise Exception("Authorization header not found")
+
+            token = authorization_header.split()[1]
+            decoded_token = jwt.decode(token, options={"verify_signature": False})
+            user_id = decoded_token.get("username")
+            if not user_id:
+                raise Exception("User ID not found in token")
+            return user_id
+        except jwt.DecodeError:
+            raise Exception("Invalid token")
+        except jwt.ExpiredSignatureError:
+            raise Exception("Expired token")
+        except Exception as e:
+            raise Exception(f"Error decoding token: {e}")
+
+    @cognito_authenticated
+    def get(self, request):
+        try:
+            username = self.get_user_id_from_token(request)
+            user = User.objects.get(user_id=username)
+            return Response(
+                {
+                    "user_id": user.user_id,
+                    "first_name": user.first_name,
+                },
+                status=status.HTTP_200_OK,
+            )
+        except User.DoesNotExist:
+            return Response({"error": "User not found"}, status=status.HTTP_404_NOT_FOUND)

authentication/views.py

@@ -3,50 +3,30 @@
 from .models import Budget
 from .serializers import BudgetSerializer
 from authentication.decorators import cognito_authenticated
-import jwt
+from authentication.utils import get_user_id_from_token
 
 
 class BudgetViewSet(viewsets.ViewSet):
-    def get_user_id_from_token(self, request):
-        try:
-            authorization_header = request.headers.get("Authorization")
-            if not authorization_header:
-                raise Exception("Authorization header not found")
-
-            token = authorization_header.split()[1]
-            decoded_token = jwt.decode(token, options={"verify_signature": False})
-            user_id = decoded_token.get("username")
-            if not user_id:
-                raise Exception("User ID not found in token")
-            return user_id
-        except jwt.DecodeError:
-            raise Exception("Invalid token")
-        except jwt.ExpiredSignatureError:
-            raise Exception("Expired token")
-        except Exception as e:
-            raise Exception(f"Error decoding token: {e}")
-
     @cognito_authenticated
     def list(self, request):
         try:
-            username = self.get_user_id_from_token(request)
-            budget = Budget.objects.filter(username=username).order_by("-created_at").first()
+            user_id = get_user_id_from_token(request)
+            budget = Budget.objects.filter(username=user_id).order_by("-created_at").first()
+            if not budget:
+                return Response({"error": "Budget not found"}, status=status.HTTP_404_NOT_FOUND)
             serializer = BudgetSerializer(budget)
             return Response(data={"amount": serializer.data["amount"]})
-        except Budget.DoesNotExist:
-            return Response({"error": "Budget not found"}, status=status.HTTP_404_NOT_FOUND)
         except Exception as e:
             return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
     @cognito_authenticated
     def create(self, request):
         try:
-            user_id = self.get_user_id_from_token(request)
+            user_id = get_user_id_from_token(request)
             data = request.data.copy()
             data["username"] = user_id
 
             serializer = BudgetSerializer(data=data)
-            print(serializer)
             if serializer.is_valid():
                 serializer.save()
                 return Response(data={"amount": serializer.data["amount"]}, status=status.HTTP_201_CREATED)
@@ -57,26 +37,26 @@ def create(self, request):
     @cognito_authenticated
     def destroy(self, request):
         try:
-            username = self.get_user_id_from_token(request)
-            budget = Budget.objects.filter(username=username).order_by("-created_at").first()
+            user_id = get_user_id_from_token(request)
+            budget = Budget.objects.filter(username=user_id).order_by("-created_at").first()
+            if not budget:
+                return Response({"error": "Budget not found"}, status=status.HTTP_404_NOT_FOUND)
             budget.delete()
             return Response(status=status.HTTP_204_NO_CONTENT)
-        except Budget.DoesNotExist:
-            return Response({"error": "Budget not found"}, status=status.HTTP_404_NOT_FOUND)
         except Exception as e:
             return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
     @cognito_authenticated
     def partial_update(self, request):
         try:
-            username = self.get_user_id_from_token(request)
-            budget = Budget.objects.filter(username=username).order_by("-created_at").first()
+            user_id = get_user_id_from_token(request)
+            budget = Budget.objects.filter(username=user_id).order_by("-created_at").first()
+            if not budget:
+                return Response({"error": "Budget not found"}, status=status.HTTP_404_NOT_FOUND)
             serializer = BudgetSerializer(budget, data=request.data, partial=True)
             if serializer.is_valid():
                 serializer.save()
                 return Response(data={"amount": serializer.data["amount"]})
             return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-        except Budget.DoesNotExist:
-            return Response({"error": "Budget not found"}, status=status.HTTP_404_NOT_FOUND)
         except Exception as e:
             return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)