.vscode/launch.json

@@ -21,15 +21,21 @@
             ]
         },
         {
-            "name": "Backend - tester",
+            "name": "Backend - test",
             "type": "debugpy",
             "request": "launch",
-            "program": "src/tester.py",
+            "module": "pytest",
+            "args": [
+                "src/tests",
+                "--log-cli-level=DEBUG",
+                "--html=report.html",
+                "--self-contained-html"
+            ],
             "env": {
                 "DEBUG": "true"
             },
             "cwd": "${workspaceFolder}/backend"
-        },
+        },        
         // frontend - flutter app
         {
             "name": "Frontend - debug",

backend/.gitignore

@@ -1,6 +1,9 @@
 # osm-cache
 cache_XML/
 
+# secrets
+*secrets.yaml
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

backend/Pipfile

@@ -25,3 +25,5 @@ loki-logger-handler = "*"
 pulp = "*"
 scipy = "*"
 requests = "*"
+supabase = "*"
+paypalrestsdk = "*"

backend/src/README.md

@@ -49,7 +49,7 @@ This file configures the logging system for the application. It defines how logs
 This file contains the main application logic and API endpoints for interacting with the system. The application is built using the FastAPI framework, which provides several endpoints for creating trips, fetching trips, and retrieving landmarks or nearby facilities. The key endpoints include:
 
 - **POST /trip/new**:
-    - This endpoint allows users to create a new trip by specifying preferences, start coordinates, and optionally end coordinates. The preferences guide the optimization process for selecting landmarks.
+    - This endpoint allows users to create a new trip by specifying user_id, preferences, start coordinates, and optionally end coordinates. The preferences guide the optimization process for selecting landmarks. The user id is needed to verify that the user's credit balance.
     - Returns: A `Trip` object containing the optimized route, landmarks, and trip details.
 
 - **GET /trip/{trip_uuid}**:

backend/src/constants.py

@@ -12,6 +12,14 @@ LANDMARK_PARAMETERS_PATH = PARAMETERS_DIR / 'landmark_parameters.yaml'
 OPTIMIZER_PARAMETERS_PATH = PARAMETERS_DIR / 'optimizer_parameters.yaml'
 
 
+PAYPAL_CLIENT_ID = os.getenv("future-paypal-client-id", None)
+PAYPAL_SECRET = os.getenv("future-paypal-secret", None)
+PAYPAL_API_URL = "https://api-m.sandbox.paypal.com"
+
+SUPABASE_URL = os.getenv("SUPABASE_URL", None)
+SUPABASE_KEY = os.getenv("SUPABASE_API_KEY", None)
+
+
 cache_dir_string = os.getenv('OSM_CACHE_DIR', './cache')
 OSM_CACHE_DIR = Path(cache_dir_string)
 

backend/src/main.py

@@ -3,7 +3,7 @@
 import logging
 import time
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Query
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Query, Body
 
 from .logging_config import configure_logging
 from .structs.landmark import Landmark, Toilets
@@ -16,6 +16,9 @@ from .optimization.optimizer import Optimizer
 from .optimization.refiner import Refiner
 from .overpass.overpass import fill_cache
 from .cache import client as cache_client
+from .payments.supabase import Supabase
+from .payments.payment_routes import router as payment_router
+from .payments.supabase_routes import router as supabase_router
 
 
 logger = logging.getLogger(__name__)
@@ -23,6 +26,7 @@ logger = logging.getLogger(__name__)
 manager = LandmarkManager()
 optimizer = Optimizer()
 refiner = Refiner(optimizer=optimizer)
+supabase = Supabase()
 
 
 @asynccontextmanager
@@ -37,10 +41,16 @@ async def lifespan(app: FastAPI):
 app = FastAPI(lifespan=lifespan)
 
 
+# Include the payment routes and supabase routes
+app.include_router(payment_router)
+app.include_router(supabase_router)
+
+
 @app.post("/trip/new")
-def new_trip(preferences: Preferences,
-             start: tuple[float, float],
-             end: tuple[float, float] | None = None, 
+def new_trip(user_id: str = Body(...),
+             preferences: Preferences = Body(...),
+             start: tuple[float, float] = Body(...),
+             end: tuple[float, float] | None = Body(None), 
              background_tasks: BackgroundTasks = None) -> Trip:
     """
     Main function to call the optimizer.
@@ -52,6 +62,19 @@ def new_trip(preferences: Preferences,
     Returns: 
         (uuid) : The uuid of the first landmark in the optimized route
     """
+    # Check for valid user balance.
+    try:
+        if not supabase.check_balance(user_id=user_id):
+            logger.warning('Insufficient credits to perform this action.')
+            return {"error": "Insufficient credits"}, 400  # Return a 400 Bad Request with an appropriate message
+    except SyntaxError as se :
+        raise HTTPException(status_code=400, detail=str(se)) from se
+    except ValueError as ve :
+        raise HTTPException(status_code=406, detail=str(ve)) from ve
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(exc)}") from exc
+
+    # Check for invalid input.
     if preferences is None:
         raise HTTPException(status_code=406, detail="Preferences not provided or incomplete.")
     if (preferences.shopping.score == 0 and
@@ -138,6 +161,7 @@ def new_trip(preferences: Preferences,
     logger.debug('Detailed trip :\n\t' + '\n\t'.join(f'{landmark}' for landmark in refined_tour))
 
     background_tasks.add_task(fill_cache)
+    supabase.decrement_credit_balance(user_id=user_id)
 
     return trip
 
@@ -244,3 +268,6 @@ def get_toilets(location: tuple[float, float] = Query(...), radius: int = 500) -
         return toilets_list
     except KeyError as exc:
         raise HTTPException(status_code=404, detail="No toilets found") from exc
+
+
+

backend/src/payments/payment_handler.py

@@ -0,0 +1,70 @@
+from typing import Literal
+import paypalrestsdk
+from pydantic import BaseModel
+from fastapi import HTTPException
+import logging
+
+
+# Model for payment request body
+class PaymentRequest(BaseModel):
+    user_id: str
+    credit_amount: Literal[10, 50, 100]
+    currency: Literal["USD", "EUR", "CHF"]  
+    description: str = "Purchase of credits"
+
+
+# Payment handler class for managing PayPal payments
+class PaymentHandler:
+
+    payment_id: str
+
+    def __init__(self, transaction_details: PaymentRequest):
+        self.details = transaction_details
+        self.logger = logging.getLogger(__name__)
+
+    # Only support purchase of credit 'bundles': 10, 50 or 100 credits worth of trip generation
+    def fetch_price(self) -> float:
+        """
+        Fetches the price of credits in the specified currency.
+        """
+        result = self.supabase.table("prices").select("credit_amount").eq("currency", self.details.currency).single().execute()
+        if result.data:
+            return result.data.get("price")
+        else:
+            self.logger.error(f"Unsupported currency: {self.details.currency}")
+            return None
+
+    def create_paypal_payment(self) -> str:
+        """
+        Creates a PayPal payment and returns the approval URL.
+        """
+        price = self.fetch_price()
+        payment = paypalrestsdk.Payment({
+            "intent": "sale",
+            "payer": {
+                "payment_method": "paypal"
+            },
+            "transactions": [{
+                "amount": {
+                    "total": f"{price:.2f}",
+                    "currency": self.details.currency
+                },
+                "description": self.details.description
+            }],
+            "redirect_urls": {
+                "return_url": "http://localhost:8000/payment/success",
+                "cancel_url": "http://localhost:8000/payment/cancel"
+            }
+        })
+
+        if payment.create():
+            self.logger.info("Payment created successfully")
+            self.payment_id = payment.id
+
+            # Get the approval URL and return it for the user to approve
+            for link in payment.links:
+                if link.rel == "approval_url":
+                    return link.href
+        else:
+            self.logger.error(f"Failed to create payment: {payment.error}")
+            raise HTTPException(status_code=500, detail="Payment creation failed")

backend/src/payments/payment_routes.py

@@ -0,0 +1,79 @@
+import logging
+import paypalrestsdk
+from fastapi import HTTPException, APIRouter
+
+from .payment_handler import PaymentRequest, PaymentHandler
+from .supabase import Supabase
+
+# Set up logging and supabase
+logger = logging.getLogger(__name__)
+supabase = Supabase()
+
+# Configure PayPal SDK
+paypalrestsdk.configure({
+    "mode": "sandbox",  # Use 'live' for production
+    "client_id": "YOUR_PAYPAL_CLIENT_ID",
+    "client_secret": "YOUR_PAYPAL_SECRET"
+})
+
+
+# Define the API router
+router = APIRouter()
+
+@router.post("/purchase/credits")
+def purchase_credits(payment_request: PaymentRequest):
+    """
+    Handles token purchases. Calculates the number of tokens based on the amount paid,
+    updates the user's balance, and processes PayPal payment.
+    """
+    payment_handler = PaymentHandler(payment_request)
+
+    # Create PayPal payment and get the approval URL
+    approval_url = payment_handler.create_paypal_payment()
+
+    return {
+        "message": "Purchase initiated successfully",
+        "payment_id": payment_handler.payment_id,
+        "credits": payment_request.credit_amount,
+        "approval_url": approval_url,
+    }
+
+
+@router.get("/payment/success")
+def payment_success(paymentId: str, PayerID: str):
+    """
+    Handles successful PayPal payment.
+    """
+    payment = paypalrestsdk.Payment.find(paymentId)
+
+    if payment.execute({"payer_id": PayerID}):
+        logger.info("Payment executed successfully")
+
+        # Retrieve transaction details from the database
+        result = supabase.table("pending_payments").select("*").eq("payment_id", paymentId).single().execute()
+        if not result.data:
+            raise HTTPException(status_code=404, detail="Transaction not found")
+
+        # Extract the necessary information
+        user_id = result.data["user_id"]
+        credit_amount = result.data["credit_amount"]
+
+        # Update the user's balance
+        supabase.increment_credit_balance(user_id, amount=credit_amount)
+
+        # Optionally, delete the pending payment entry since the transaction is completed
+        supabase.table("pending_payments").delete().eq("payment_id", paymentId).execute()
+
+        return {"message": "Payment completed successfully"}
+    else:
+        logger.error(f"Payment execution failed: {payment.error}")
+        raise HTTPException(status_code=500, detail="Payment execution failed")
+
+
+@router.get("/payment/cancel")
+def payment_cancel():
+    """
+    Handles PayPal payment cancellation.
+    """
+    return {"message": "Payment was cancelled"}
+

backend/src/payments/supabase.py

@@ -0,0 +1,170 @@
+import os
+import logging
+import yaml
+from fastapi import HTTPException, status
+from supabase import create_client, Client, ClientOptions
+
+from ..constants import PARAMETERS_DIR
+
+# Silence the supabase logger
+logging.getLogger("httpx").setLevel(logging.CRITICAL)
+logging.getLogger("hpack").setLevel(logging.CRITICAL)
+logging.getLogger("httpcore").setLevel(logging.CRITICAL)
+
+
+class Supabase:
+
+    logger = logging.getLogger(__name__)
+
+    def __init__(self):
+
+        with open(os.path.join(PARAMETERS_DIR, 'secrets.yaml')) as f:
+            secrets = yaml.safe_load(f)
+            self.SUPABASE_URL = secrets['SUPABASE_URL']
+            self.SUPABASE_ADMIN_KEY = secrets['SUPABASE_ADMIN_KEY']
+            self.SUPABASE_TEST_USER_ID = secrets['SUPABASE_TEST_USER_ID']
+
+        self.supabase = create_client(
+            self.SUPABASE_URL, 
+            self.SUPABASE_ADMIN_KEY, 
+            options=ClientOptions(schema='public')
+        )
+        self.logger.debug('Supabase client initialized.')
+
+
+    def check_balance(self, user_id: str) -> bool:
+        """
+        Checks if the user has enough 'credit' for generating a new trip.
+
+        Args:
+            user_id (str): The ID of the current user.
+
+        Returns:
+            bool: True if the balance is positive, False otherwise.
+        """
+        try:
+            # Query the public.credits table to get the user's credits
+            response = (
+                self.supabase.table("credits")
+                .select('*')
+                .eq('id', user_id)
+                .single()
+                .execute()
+            )
+            # self.logger.critical(response)
+
+        except Exception as e:
+            if e.code == '22P02' :
+                self.logger.error(f"Failed querying credits : {str(e)}")
+                raise SyntaxError(f"Failed querying credits : {str(e)}") from e
+            if e.code == 'PGRST116' :
+                self.logger.error(f"User not found : {str(e)}")
+                raise ValueError(f"User not found : {str(e)}") from e
+            else :
+                self.logger.error(f"An unexpected error occured while checking user balance : {str(e)}")
+                raise Exception(f"An unexpected error occured while checking user balance : {str(e)}") from e
+
+        # Proceed to check the user's credit balance
+        credits = response.data['credit_amount']
+        self.logger.debug(f'Credits of user {user_id}: {credits}')
+
+        if credits > 0:
+            self.logger.info(f'Credit balance is positive for user {user_id}. Proceeding with trip generation.')
+            return True
+
+        self.logger.warning(f'Insufficient balance for user {user_id}. Trip generation cannot proceed.')
+        return False
+
+
+    def decrement_credit_balance(self, user_id: str, amount: int=1) -> bool:
+        """
+        Decrements the user's credit balance by 1.
+
+        Args:
+            user_id (str): The ID of the current user.
+        """
+        try:
+            # Query the public.credits table to get the user's current credits
+            response = (
+                self.supabase.table("credits")
+                .select('*')
+                .eq('id', user_id)
+                .single()
+                .execute()
+            )
+        except Exception as e:
+            if e.code == '22P02' :
+                self.logger.error(f"Failed decrementing credits : {str(e)}")
+                raise SyntaxError(f"Failed decrementing credits : {str(e)}") from e
+            if e.code == 'PGRST116' :
+                self.logger.error(f"User not found : {str(e)}")
+                raise ValueError(f"User not found : {str(e)}") from e
+            else :
+                self.logger.error(f"An unexpected error occured while decrementing user balance : {str(e)}")
+                raise Exception(f"An unexpected error occured while decrementing user balance : {str(e)}") from e
+
+
+        current_credits = response.data['credit_amount']
+        updated_credits = current_credits - amount
+
+        # Update the user's credits in the table
+        update_response = (
+            self.supabase.table('credits')
+            .update({'credit_amount': updated_credits})
+            .eq('id', user_id)
+            .execute()
+        )
+
+        # Check if the update was successful
+        if update_response.data:
+            self.logger.debug(f'Credit balance successfully decremented.')
+            return True
+        else:
+            raise Exception("Error decrementing credit balance.")
+
+
+    def increment_credit_balance(self, user_id: str, amount: int=1) -> bool:
+        """
+        Increments the user's credit balance by 1.
+
+        Args:
+            user_id (str): The ID of the current user.
+        """
+        try:
+            # Query the public.credits table to get the user's current credits
+            response = (
+                self.supabase.table("credits")
+                .select('*')
+                .eq('id', user_id)
+                .single()
+                .execute()
+            )
+        except Exception as e:
+            if e.code == '22P02' :
+                self.logger.error(f"Failed incrementing credits : {str(e)}")
+                raise SyntaxError(f"Failed incrementing credits : {str(e)}") from e
+            if e.code == 'PGRST116' :
+                self.logger.error(f"User not found : {str(e)}")
+                raise ValueError(f"User not found : {str(e)}") from e
+            else :
+                self.logger.error(f"An unexpected error occured while incrementing user balance : {str(e)}")
+                raise Exception(f"An unexpected error occured while incrementing user balance : {str(e)}") from e
+
+
+        current_credits = response.data['credit_amount']
+        updated_credits = current_credits + amount
+
+        # Update the user's credits in the table
+        update_response = (
+            self.supabase.table('credits')
+            .update({'credit_amount': updated_credits})
+            .eq('id', user_id)
+            .execute()
+        )
+
+        # Check if the update was successful
+        if update_response.data:
+            self.logger.debug(f'Credit balance successfully incremented.')
+            return True
+        else:
+            raise Exception("Error incrementing credit balance.")

backend/src/payments/supabase_routes.py

@@ -0,0 +1,52 @@
+"""Endpoints for supabase user handling."""
+import logging
+from fastapi import APIRouter, HTTPException
+
+from .supabase import Supabase
+
+
+# Set up logging and supabase.
+logger = logging.getLogger(__name__)
+supabase = Supabase()
+
+# Create fastapi router
+router = APIRouter()
+
+
+@router.post("/user/create/{email}/{password}")
+def register_user(email: str, password: str) -> str:
+    try:
+        response = supabase.supabase.auth.admin.create_user({
+            "email": email,
+            "password": password
+        })
+
+    except Exception as e:
+        if e.code == 'email_exists' :
+            logger.error(f"Failed to create user : {str(e.code)}")
+            raise HTTPException(status_code=422, detail=str(e)) from e
+        logger.error(f"Failed to create user : {str(e.code)}")
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+    # Extract the identity_id and user_id
+    user_id = response.user.id
+
+    logger.info(f"User created successfully, ID: {user_id}")
+    return user_id
+
+
+
+@router.post("/user/delete/{user_id}")
+def delete_user(user_id: str):
+
+    try:
+        response = supabase.supabase.auth.admin.delete_user(user_id)
+        logger.debug(response)
+    except Exception as e:
+        if e.code == 'user_not_found' :
+            logger.error(f"Failed to delete user : {str(e.code)}")
+            raise HTTPException(status_code=404, detail=str(e)) from e
+        logger.error(f"Failed to create user : {str(e.code)}")
+        raise HTTPException(status_code=500, detail=str(e)) from e
+    
+    logger.info(f"User with ID {user_id} deleted successfully")

backend/src/tests/test_invalid_input.py

@@ -4,6 +4,7 @@ from fastapi.testclient import TestClient
 import pytest
 
 from ..main import app
+from ..constants import SUPABASE_TEST_USER_ID
 
 
 @pytest.fixture(scope="module")
@@ -55,8 +56,38 @@ def test_input(invalid_client, start, preferences, status_code):   # pylint: dis
     response = invalid_client.post(
         "/trip/new",
         json={
+            "user_id": SUPABASE_TEST_USER_ID,
             "preferences": preferences,
             "start": start
         }
     )
     assert response.status_code == status_code
+
+
+
+@pytest.mark.parametrize(
+    "user_id,status_code",
+    [
+        # No user id :
+        ({}, 422),
+        ("invalid_user_id", 400),
+        # ("12345678-1234-5678-1234-567812345678", 406)
+    ]
+)
+def test_input(invalid_client, user_id, status_code):   # pylint: disable=redefined-outer-name
+    """
+    Test new trip creation with invalid user ID.
+    """
+    response = invalid_client.post(
+        "/trip/new",
+        json={
+            "user_id": user_id,
+            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
+                "nature": {"type": "nature", "score": 0},
+                "shopping": {"type": "shopping", "score": 0},
+                "max_time_minute": 20,
+                "detour_tolerance_minute": 0},
+            "start": [48.084588, 7.280405]
+        }
+    )
+    assert response.status_code == status_code

backend/src/tests/test_main.py

@@ -1,10 +1,17 @@
 """Collection of tests to ensure correct implementation and track progress. """
 import time
+import logging
 from fastapi.testclient import TestClient
 import pytest
 
 from .test_utils import load_trip_landmarks, log_trip_details
 from ..main import app
+from ..payments.supabase import Supabase
+
+supabase = Supabase()
+logger = logging.getLogger(__name__)
+USER_ID = supabase.SUPABASE_TEST_USER_ID
+
 
 @pytest.fixture(scope="module")
 def client():
@@ -22,21 +29,24 @@ def test_turckheim(client, request):    # pylint: disable=redefined-outer-name
     """
     start_time = time.time()  # Start timer
     duration_minutes = 20
+    logger.debug('Running test in Turckheim')
 
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-            "nature": {"type": "nature", "score": 0},
-            "shopping": {"type": "shopping", "score": 0},
-            "max_time_minute": duration_minutes,
-            "detour_tolerance_minute": 0},
+                "nature": {"type": "nature", "score": 0},
+                "shopping": {"type": "shopping", "score": 0},
+                "max_time_minute": duration_minutes,
+                "detour_tolerance_minute": 0},
             "start": [48.084588, 7.280405]
             # "start": [45.74445023349939, 4.8222687890538865]
             # "start": [45.75156398104873, 4.827154464827647]
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
 
@@ -58,6 +68,8 @@ def test_turckheim(client, request):    # pylint: disable=redefined-outer-name
     assert duration_minutes*1.2 > result['total_time'], f"Trip too long: {result['total_time']} instead of {duration_minutes}"
     # assert 2!= 3
 
+
+
 def test_bellecour(client, request) :   # pylint: disable=redefined-outer-name
     """
     Test n°2 : Custom test in Lyon centre to ensure proper decision making in crowded area.
@@ -73,6 +85,7 @@ def test_bellecour(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
                             "nature": {"type": "nature", "score": 5},
                             "shopping": {"type": "shopping", "score": 5},
@@ -82,6 +95,7 @@ def test_bellecour(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -113,6 +127,7 @@ def test_cologne(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
                             "nature": {"type": "nature", "score": 5},
                             "shopping": {"type": "shopping", "score": 5},
@@ -122,6 +137,7 @@ def test_cologne(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -154,6 +170,7 @@ def test_strasbourg(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
                             "nature": {"type": "nature", "score": 5},
                             "shopping": {"type": "shopping", "score": 5},
@@ -163,6 +180,7 @@ def test_strasbourg(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -195,6 +213,7 @@ def test_zurich(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
                             "nature": {"type": "nature", "score": 5},
                             "shopping": {"type": "shopping", "score": 5},
@@ -204,6 +223,7 @@ def test_zurich(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -236,6 +256,7 @@ def test_paris(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
                             "nature": {"type": "nature", "score": 0},
                             "shopping": {"type": "shopping", "score": 5},
@@ -245,6 +266,7 @@ def test_paris(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -277,6 +299,7 @@ def test_new_york(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
                             "nature": {"type": "nature", "score": 5},
                             "shopping": {"type": "shopping", "score": 5},
@@ -286,6 +309,7 @@ def test_new_york(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -318,6 +342,7 @@ def test_shopping(client, request) :   # pylint: disable=redefined-outer-name
     response = client.post(
         "/trip/new",
         json={
+            "user_id": USER_ID,
             "preferences": {"sightseeing": {"type": "sightseeing", "score": 0},
                             "nature": {"type": "nature", "score": 0},
                             "shopping": {"type": "shopping", "score": 5},
@@ -327,6 +352,7 @@ def test_shopping(client, request) :   # pylint: disable=redefined-outer-name
             }
         )
     result = response.json()
+    supabase.increment_credit_balance(user_id=USER_ID)
     landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
 
     # Get computation time
@@ -342,4 +368,4 @@ def test_shopping(client, request) :   # pylint: disable=redefined-outer-name
     assert response.status_code == 200  # check for successful planning
     assert comp_time < 30, f"Computation time exceeded 30 seconds: {comp_time:.2f} seconds"
     assert duration_minutes*0.8 < result['total_time'], f"Trip too short: {result['total_time']} instead of {duration_minutes}"
-    assert duration_minutes*1.2 > result['total_time'], f"Trip too long: {result['total_time']} instead of {duration_minutes}"
+    assert duration_minutes*1.2 > result['total_time'], f"Trip too long: {result['total_time']} instead of {duration_minutes}"

backend/src/tests/test_user.py

@@ -0,0 +1,48 @@
+"""Collection of tests to ensure correct handling of user data."""
+
+from fastapi.testclient import TestClient
+import pytest
+
+from ..main import app
+
+TEST_EMAIL = "dummy@example.com"
+TEST_PW = "DummyPassword123"
+
+@pytest.fixture(scope="module")
+def client():
+    """Client used to call the app."""
+    return TestClient(app)
+
+
+def test_user_handling(client) :
+    """
+    Test the creation of a new user.
+    """
+    # Create a new user
+    response = client.post(f"/user/create/{TEST_EMAIL}/{TEST_PW}")
+
+    # Verify user has been created
+    assert response.status_code == 200, "Failed to create dummy user"
+    user_id = response.json()
+
+
+    # Create same user again to raise an error
+    response = client.post(f"/user/create/{TEST_EMAIL}/{TEST_PW}")
+    # Verify user already exists
+    assert response.status_code == 422, "Failed to simulate dummy user already created."
+
+
+    # Delete the user.
+    response = client.post(f"/user/delete/{user_id}")
+
+    # Verify user has been deleted
+    assert response.status_code == 200, "Failed to delete dummy user."
+
+
+    # Delete the user again to raise an error
+    response = client.post(f"/user/delete/{user_id}")
+    # Verify user has been deleted
+    assert response.status_code == 404, "Failed to simulate dummy user already deleted."
+
+
+

backend/src/utils/cluster_manager.py

@@ -134,7 +134,7 @@ class ClusterManager:
 
                 # Check that there are is least 1 cluster
                 if len(set(labels)) > 1 :
-                    self.logger.info(f"Found {len(set(labels))} different {cluster_type} clusters.")
+                    self.logger.info(f"Found {len(set(labels))} {cluster_type} clusters.")
                     # Separate clustered points and noise points
                     self.cluster_points = self.all_points[labels != -1]
                     self.cluster_labels = labels[labels != -1]

frontend/lib/utils/fetch_trip.dart

@@ -33,6 +33,7 @@ fetchTrip(
   UserPreferences preferences,
 ) async {
   Map<String, dynamic> data = {
+    // Add user ID here for API request
     "preferences": preferences.toJson(),
     "start": trip.landmarks!.first.location,
   };