i am stoopid

- Added landmarks_router.py to handle landmark retrieval based on user preferences and location.
- Implemented optimization_router.py for trip optimization, including handling preferences and landmarks.
- Created toilets_router.py to fetch toilet locations within a specified radius from a given location.
- Enhanced error handling and logging across all new endpoints.
- Generated a comprehensive report.html for test results and environment details.

.gitea/workflows/backend_run_lint.yaml

@@ -15,18 +15,18 @@ jobs:
 
     - uses: https://gitea.com/actions/checkout@v4
 
-    - name: Install dependencies
+    - name: Install pylint
       run: |
         apt-get update && apt-get install -y python3 python3-pip
-        pip install pipenv        
+        pip install pylint        
 
-    - name: Install packages
-      run: |
-        ls -la
-        # only install dev-packages
-        pipenv install --categories=dev-packages
-      working-directory: backend
+    # - name: Install packages
+    #   run: |
+    #     ls -la
+    #     # only install dev-packages
+    #     uv sync
+    #   working-directory: backend
 
     - name: Run linter
-      run: pipenv run pylint src --fail-under=9 
+      run: pylint src --fail-under=9 
       working-directory: backend

.gitea/workflows/backend_run_test.yaml

@@ -18,17 +18,17 @@ jobs:
     - name: Install dependencies
       run: |
         apt-get update && apt-get install -y python3 python3-pip
-        pip install pipenv        
+        pip install uv        
 
     - name: Install packages
       run: |
         ls -la
         # install all packages, including dev-packages
-        pipenv install --dev
+        uv sync
       working-directory: backend
 
     - name: Run Tests
-      run: pipenv run pytest src --html=report.html --self-contained-html --log-cli-level=INFO
+      run: uv run pytest src --html=report.html --self-contained-html --log-cli-level=DEBUG
       working-directory: backend
 
     - name: Upload HTML report

LICENSE.md

@@ -0,0 +1,30 @@
+# License
+
+## Proprietary License
+
+All code and resources in this repository are the property of AnyDev. The software and related documentation are provided solely for use with services provided by AnyDev. Redistribution, modification, or use of this software outside of its intended service is strictly prohibited without explicit permission.
+
+### Copyright © 2024 AnyDev
+
+All rights reserved.
+
+### Restrictions
+
+- You may not modify, distribute, copy, or reverse engineer any part of this codebase.
+- This software is licensed for use solely in conjunction with services provided by AnyDev.
+- Any commercial use of this software is strictly prohibited without explicit written consent from AnyDev.
+
+## Third-Party Dependencies
+
+This project uses third-party dependencies, which are subject to their respective licenses.
+
+- Python backend dependencies: fastapi, pydantic, numpy, shapely, etc. – Licensed under their respective licenses.
+- Flutter frontend dependencies: Cupertino Icons, sliding_up_panel, http, etc. – Licensed under their respective licenses.
+
+Please refer to each project's documentation for the specific terms and conditions.
+
+## OpenStreetMap Data Usage
+
+This project uses data derived from **OpenStreetMap**. OpenStreetMap data is available under the [Open Database License (ODbL)](https://www.openstreetmap.org/copyright). We comply with the ODbL license, and some of the data displayed in the service may be derived from OpenStreetMap sources. We do not redistribute raw OpenStreetMap data; instead, it is processed and transformed before being used in our services.
+
+More information about OpenStreetMap data usage can be found [here](https://www.openstreetmap.org/copyright).

backend/.gitignore

@@ -1,6 +1,9 @@
 # osm-cache
 cache_XML/
 
+# secrets
+*secrets.yaml
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -9,6 +12,9 @@ __pycache__/
 # C extensions
 *.so
 
+# Pytest html reports
+*.html
+
 # Distribution / packaging
 .Python
 build/

backend/.pylintrc

@@ -445,7 +445,9 @@ disable=raw-checker-failed,
         logging-fstring-interpolation,
         duplicate-code,
         relative-beyond-top-level, 
-        invalid-name
+        invalid-name,
+        too-many-arguments,
+        too-many-positional-arguments
 
 # Enable the message, report, category or checker with the given id(s). You can
 # either give multiple identifier separated by comma (,) or put this option

backend/.python-version

@@ -0,0 +1 @@
+3.12.9

backend/Dockerfile

@@ -1,11 +1,29 @@
-FROM python:3.11-slim
+FROM python:3.12-slim-bookworm
 
+# The installer requires curl (and certificates) to download the release archive
+RUN apt-get update && apt-get install -y --no-install-recommends curl ca-certificates
+
+# Download the latest installer
+ADD https://astral.sh/uv/install.sh /uv-installer.sh
+
+# Run the installer then remove it
+RUN sh /uv-installer.sh && rm /uv-installer.sh
+
+# Ensure the installed binary is on the `PATH`
+ENV PATH="/root/.local/bin/:$PATH"
+
+# Set the working directory
 WORKDIR /app
-COPY Pipfile Pipfile.lock .
 
-RUN pip install pipenv
-RUN pipenv install --deploy --system
+# Copy uv files
+COPY pyproject.toml pyproject.toml
+COPY uv.lock uv.lock
+COPY .python-version .python-version
 
+# Sync the venv
+RUN uv sync --frozen --no-cache --no-dev
+
+# Copy application files
 COPY src src
 
 EXPOSE 8000
@@ -17,4 +35,4 @@ ENV MEMCACHED_HOST_PATH=none
 ENV LOKI_URL=none
 
 # explicitly use a string instead of an argument list to force a shell and variable expansion
-CMD fastapi run src/main.py --port 8000 --workers $NUM_WORKERS
+CMD uv run fastapi run src/main.py --port 8000 --workers $NUM_WORKERS

backend/Pipfile

@@ -1,27 +0,0 @@
-[[source]]
-url = "https://pypi.org/simple"
-verify_ssl = true
-name = "pypi"
-
-[dev-packages]
-pylint = "*"
-pytest = "*"
-tomli = "*"
-httpx = "*"
-exceptiongroup = "*"
-pytest-html = "*"
-typing-extensions = "*"
-dill = "*"
-
-[packages]
-numpy = "*"
-fastapi = "*"
-pydantic = "*"
-shapely = "*"
-pymemcache = "*"
-fastapi-cli = "*"
-scikit-learn = "*"
-loki-logger-handler = "*"
-pulp = "*"
-scipy = "*"
-requests = "*"

backend/README.md

@@ -6,31 +6,31 @@ This repository contains the backend code for the application. It utilizes **Fas
 
 ### Directory Structure
 - The code for the Python application is located in the `src` directory.
-- Package management is handled with **pipenv**, and the dependencies are listed in the `Pipfile`.
+- Package management is handled with **uv**, and the dependencies are listed in the `pyproject.toml` file.
 - Since the application is designed to be deployed in a container, the `Dockerfile` is provided to build the image.
 
 ### Setting Up the Development Environment
 
-To set up your development environment using **pipenv**, follow these steps:
+To set up your development environment using **uv**, follow these steps:
 
-1. Install `pipenv` by running:
+1. Make sure you find yourself in the `backend` directory:
     ```bash
-    sudo apt install pipenv
+    cd backend
     ```
 
-2. Create and activate a virtual environment:
+1. Install `uv` by running:
     ```bash
-    pipenv shell
+    curl -LsSf https://astral.sh/uv/install.sh | sh
     ```
 
-3. Install the dependencies listed in the `Pipfile`:
+3. Install the dependencies listed in `pyproject.toml` and create the virtual environment at the same time:
     ```bash
-    pipenv install
+    uv sync
     ```
 
 4. The virtual environment will be created under:
     ```bash
-    ~/.local/share/virtualenvs/...
+    backend/.venv/...
     ```
 
 ### Deployment

backend/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from backend!")
+
+
+if __name__ == "__main__":
+    main()

backend/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "backend"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "annotated-types==0.7.0 ; python_full_version >= '3.8'",
+    "anyio==4.8.0 ; python_full_version >= '3.9'",
+    "certifi==2024.12.14 ; python_full_version >= '3.6'",
+    "charset-normalizer==3.4.1 ; python_full_version >= '3.7'",
+    "click==8.1.8 ; python_full_version >= '3.7'",
+    "fastapi==0.115.7 ; python_full_version >= '3.8'",
+    "fastapi-cli==0.0.7 ; python_full_version >= '3.8'",
+    "h11==0.14.0 ; python_full_version >= '3.7'",
+    "httptools==0.6.4",
+    "idna==3.10 ; python_full_version >= '3.6'",
+    "joblib==1.4.2 ; python_full_version >= '3.8'",
+    "loki-logger-handler==1.1.0 ; python_full_version >= '2.7'",
+    "markdown-it-py==3.0.0 ; python_full_version >= '3.8'",
+    "mdurl==0.1.2 ; python_full_version >= '3.7'",
+    "numpy==2.2.2 ; python_full_version >= '3.10'",
+    "paypalrestsdk>=1.13.3",
+    "pulp==2.9.0 ; python_full_version >= '3.7'",
+    "pydantic==2.10.6 ; python_full_version >= '3.8'",
+    "pydantic-core==2.27.2 ; python_full_version >= '3.8'",
+    "pygments==2.19.1 ; python_full_version >= '3.8'",
+    "pymemcache==4.0.0 ; python_full_version >= '3.7'",
+    "python-dotenv==1.0.1",
+    "pyyaml==6.0.2",
+    "requests==2.32.3 ; python_full_version >= '3.8'",
+    "rich==13.9.4 ; python_full_version >= '3.8'",
+    "rich-toolkit==0.13.2 ; python_full_version >= '3.8'",
+    "scikit-learn==1.6.1 ; python_full_version >= '3.9'",
+    "scipy==1.15.1 ; python_full_version >= '3.10'",
+    "shapely==2.0.6 ; python_full_version >= '3.7'",
+    "shellingham==1.5.4 ; python_full_version >= '3.7'",
+    "sniffio==1.3.1 ; python_full_version >= '3.7'",
+    "starlette==0.45.3 ; python_full_version >= '3.9'",
+    "supabase>=2.16.0",
+    "threadpoolctl==3.5.0 ; python_full_version >= '3.8'",
+    "typer==0.15.1 ; python_full_version >= '3.7'",
+    "typing-extensions==4.12.2 ; python_full_version >= '3.8'",
+    "urllib3==2.3.0 ; python_full_version >= '3.9'",
+    "uvicorn[standard]==0.34.0 ; python_full_version >= '3.9'",
+    "uvloop==0.21.0",
+    "watchfiles==1.0.4",
+    "websockets==14.2",
+]
+
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
+    "ipykernel>=6.30.0",
+    "pytest>=8.4.1",
+    "pytest-html>=4.1.1",
+]

backend/src/README.md

@@ -28,6 +28,11 @@ This folder defines the commonly used data structures used within the project. T
 ### src/tests
 This folder contains unit tests and test cases for the application's various modules. It is used to ensure the correctness and stability of the code.
 
+Run the unit tests with the following command:
+```bash
+uv run pytest src --log-cli-level=DEBUG --html=report.html --self-contained-html
+```
+
 ### src/utils
 The `utils` folder contains utility classes and functions that provide core functionality for the application. The main component in this folder is the `LandmarkManager`, which is central to the process of fetching and organizing landmarks.
 

backend/src/constants.py

@@ -2,6 +2,7 @@
 
 import os
 from pathlib import Path
+from typing import List, Literal, Tuple
 
 
 LOCATION_PREFIX = Path('src')
@@ -14,6 +15,8 @@ OPTIMIZER_PARAMETERS_PATH = PARAMETERS_DIR / 'optimizer_parameters.yaml'
 cache_dir_string = os.getenv('OSM_CACHE_DIR', './cache')
 OSM_CACHE_DIR = Path(cache_dir_string)
 
+OSM_TYPES = List[Literal['way', 'node', 'relation']]
+BBOX = Tuple[float, float, float, float]
 
 MEMCACHED_HOST_PATH = os.getenv('MEMCACHED_HOST_PATH', None)
 if MEMCACHED_HOST_PATH == "none":

backend/src/landmarks/cluster_manager.py

@@ -1,6 +1,6 @@
 """Find clusters of interest to add more general areas of visit to the tour."""
 import logging
-from typing import Literal
+from typing import Literal, Tuple
 
 import numpy as np
 from sklearn.cluster import DBSCAN
@@ -8,8 +8,9 @@ from pydantic import BaseModel
 
 from ..overpass.overpass import Overpass, get_base_info
 from ..structs.landmark import Landmark
-from .get_time_distance import get_distance
-from ..constants import OSM_CACHE_DIR
+from ..utils.get_time_distance import get_distance
+from ..utils.bbox import create_bbox
+
 
 
 # silence the overpass logger
@@ -32,7 +33,7 @@ class Cluster(BaseModel):
     """
     type: Literal['street', 'area']
     importance: int
-    centroid: tuple
+    centroid: Tuple[float, float]
     # start: Optional[list] = None      # for later use if we want to have streets as well
     # end: Optional[list] = None
 
@@ -79,8 +80,7 @@ class ClusterManager:
             bbox: The bounding box coordinates (around:radius, center_lat, center_lon).
         """
         # Setup the caching in the Overpass class.
-        self.overpass = Overpass(caching_strategy='XML', cache_dir=OSM_CACHE_DIR)
-
+        self.overpass = Overpass()
 
         self.cluster_type = cluster_type
         if cluster_type == 'shopping' :
@@ -95,32 +95,29 @@ class ClusterManager:
             raise NotImplementedError("Please choose only an available option for cluster detection")
 
         # Initialize the points for cluster detection
-        query = self.overpass.build_query(
-            area = bbox,
+        try:
+            result = self.overpass.send_query(
+            bbox = bbox,
             osm_types = osm_types,
             selector = sel,
             out = out
         )
-        self.logger.debug(f"Cluster query: {query}")
-
-        try:
-            result = self.overpass.send_query(query)
         except Exception as e:
-            self.logger.error(f"Error fetching landmarks: {e}")
+            self.logger.warning(f"Error fetching clusters: {e}")
 
         if result is None :
-            self.logger.error(f"Error fetching {cluster_type} clusters, overpass query returned None.")
+            self.logger.debug(f"Found no {cluster_type} clusters, overpass query returned no datapoints.")
             self.valid = False
 
         else :
             points = []
-            for osm_type in osm_types :
-                for elem in result.findall(osm_type):
-                    
-                    # Get coordinates and append them to the points list
-                    _, coords = get_base_info(elem, osm_type)
-                    if coords is not None :
-                        points.append(coords)
+            for elem in result:
+                osm_type = elem.get('type')
+
+                # Get coordinates and append them to the points list
+                _, coords = get_base_info(elem, osm_type)
+                if coords is not None :
+                    points.append(coords)
 
             if points :
                 self.all_points = np.array(points)
@@ -137,7 +134,7 @@ class ClusterManager:
 
                 # Check that there are is least 1 cluster
                 if len(set(labels)) > 1 :
-                    self.logger.debug(f"Found {len(set(labels))} different clusters.")
+                    self.logger.info(f"Found {len(set(labels))} different {cluster_type} clusters.")
                     # Separate clustered points and noise points
                     self.cluster_points = self.all_points[labels != -1]
                     self.cluster_labels = labels[labels != -1]
@@ -145,11 +142,11 @@ class ClusterManager:
                     self.valid = True
 
                 else :
-                    self.logger.debug(f"Detected 0 {cluster_type} clusters.")
+                    self.logger.info(f"Found 0 {cluster_type} clusters.")
                     self.valid = False
 
             else :
-                self.logger.debug(f"Detected 0 {cluster_type} clusters.")
+                self.logger.debug(f"Found 0 {cluster_type} clusters.")
                 self.valid = False
 
 
@@ -181,11 +178,12 @@ class ClusterManager:
 
             # Calculate the centroid as the mean of the points
             centroid = np.mean(current_cluster, axis=0)
+            centroid = tuple((round(centroid[0], 7), round(centroid[1], 7)))
 
             if self.cluster_type == 'shopping' :
-                score = len(current_cluster)*2
+                score = len(current_cluster)*3
             else :
-                score = len(current_cluster)*8
+                score = len(current_cluster)*15
             locations.append(Cluster(
                 type='area',
                 centroid=centroid,
@@ -218,8 +216,7 @@ class ClusterManager:
         """
 
         # Define the bounding box for a given radius around the coordinates
-        lat, lon = cluster.centroid
-        bbox = (1000, lat, lon)
+        bbox = create_bbox(cluster.centroid, 300)
 
         # Query neighborhoods and shopping malls
         selectors = ['"place"~"^(suburb|neighborhood|neighbourhood|quarter|city_block)$"']
@@ -227,10 +224,10 @@ class ClusterManager:
         if self.cluster_type == 'shopping' :
             selectors.append('"shop"="mall"')
             new_name = 'Shopping Area'
-            t = 40
+            t = 30
         else :
             new_name = 'Neighborhood'
-            t = 15
+            t = 20
 
         min_dist = float('inf')
         osm_id = 0
@@ -238,37 +235,32 @@ class ClusterManager:
         osm_types = ['node', 'way', 'relation']
 
         for sel in selectors :
-            query = self.overpass.build_query(
-                area = bbox,
-                osm_types = osm_types,
-                selector = sel,
-                out = 'ids center'
-            )
-
             try:
-                result = self.overpass.send_query(query)
+                result = self.overpass.send_query(bbox = bbox,
+                                                  osm_types = osm_types,
+                                                  selector = sel,
+                                                  out = 'ids center tags'
+                                                  )
             except Exception as e:
-                self.logger.error(f"Error fetching landmarks: {e}")
+                self.logger.warning(f"Error fetching clusters: {e}")
                 continue
 
             if result is None :
-                self.logger.error(f"Error fetching landmarks: {e}")
+                self.logger.warning(f"Error fetching clusters: query result is None")
                 continue
 
-            for osm_type in osm_types :
-                for elem in result.findall(osm_type):
+            for elem in result:
+                # Get basic info
+                id, coords, name = get_base_info(elem, elem.get('type'), with_name=True)
+                if name is None or coords is None :
+                    continue
 
-                    id, coords, name = get_base_info(elem, osm_type, with_name=True)
-
-                    if name is None or coords is None :
-                        continue
-
-                    d = get_distance(cluster.centroid, coords)
-                    if  d < min_dist :
-                        min_dist = d
-                        new_name = name
-                        osm_type = osm_type     # Add type: 'way' or 'relation'
-                        osm_id = id             # Add OSM id
+                d = get_distance(cluster.centroid, coords)
+                if  d < min_dist :
+                    min_dist = d
+                    new_name = name             # add name
+                    osm_type = elem.get('type') # add type: 'way' or 'relation'
+                    osm_id = id                 # add OSM id
 
         return Landmark(
             name=new_name,

backend/src/landmarks/landmarks_manager.py

@@ -1,19 +1,14 @@
 """Module used to import data from OSM and arrange them in categories."""
 import logging
-import xml.etree.ElementTree as ET
 import yaml
 
-
 from ..structs.preferences import Preferences
 from ..structs.landmark import Landmark
-from .take_most_important import take_most_important
 from .cluster_manager import ClusterManager
 from ..overpass.overpass import Overpass, get_base_info
+from ..utils.bbox import create_bbox
 
-from ..constants import AMENITY_SELECTORS_PATH, LANDMARK_PARAMETERS_PATH, OPTIMIZER_PARAMETERS_PATH, OSM_CACHE_DIR
-
-# silence the overpass logger
-logging.getLogger('Overpass').setLevel(level=logging.CRITICAL)
+from ..constants import AMENITY_SELECTORS_PATH, LANDMARK_PARAMETERS_PATH, OPTIMIZER_PARAMETERS_PATH
 
 
 class LandmarkManager:
@@ -27,7 +22,7 @@ class LandmarkManager:
     church_coeff: float     # coeff to adjsut score of churches
     nature_coeff: float       # coeff to adjust score of parks
     overall_coeff: float        # coeff to adjust weight of tags
-    n_important: int        # number of important landmarks to consider
+    # n_important: int        # number of important landmarks to consider
 
 
     def __init__(self) -> None:
@@ -37,18 +32,16 @@ class LandmarkManager:
 
         with LANDMARK_PARAMETERS_PATH.open('r') as f:
             parameters = yaml.safe_load(f)
-            self.max_bbox_side = parameters['city_bbox_side']
-            self.radius_close_to = parameters['radius_close_to']
+            self.max_bbox_side = parameters['max_bbox_side']
             self.church_coeff = parameters['church_coeff']
             self.nature_coeff = parameters['nature_coeff']
             self.overall_coeff = parameters['overall_coeff']
             self.tag_exponent = parameters['tag_exponent']
             self.image_bonus = parameters['image_bonus']
-            self.name_bonus = parameters['name_bonus']
             self.wikipedia_bonus = parameters['wikipedia_bonus']
             self.viewpoint_bonus = parameters['viewpoint_bonus']
             self.pay_bonus = parameters['pay_bonus']
-            self.n_important = parameters['N_important']
+            # self.n_important = parameters['N_important']
 
         with OPTIMIZER_PARAMETERS_PATH.open('r') as f:
             parameters = yaml.safe_load(f)
@@ -56,12 +49,17 @@ class LandmarkManager:
             self.detour_factor = parameters['detour_factor']
 
         # Setup the caching in the Overpass class.
-        self.overpass = Overpass(caching_strategy='XML', cache_dir=OSM_CACHE_DIR)
+        self.overpass = Overpass()
 
         self.logger.info('LandmakManager successfully initialized.')
 
 
-    def generate_landmarks_list(self, center_coordinates: tuple[float, float], preferences: Preferences) -> tuple[list[Landmark], list[Landmark]]:
+    def generate_landmarks_list(
+            self,
+            center_coordinates: tuple[float, float],
+            preferences: Preferences,
+            allow_clusters: bool = True
+            ) -> list[Landmark] :
         """
         Generate and prioritize a list of landmarks based on user preferences.
 
@@ -69,68 +67,71 @@ class LandmarkManager:
         and current location. It scores and corrects these landmarks, removes duplicates, and then selects the most important
         landmarks based on a predefined criterion.
 
-        Args:
-        center_coordinates (tuple[float, float]): The latitude and longitude of the center location around which to search.
-        preferences (Preferences): The user's preference settings that influence the landmark selection.
+        Parameters :
+            center_coordinates (tuple[float, float]): The latitude and longitude of the center location around which to search.
+            preferences (Preferences): The user's preference settings that influence the landmark selection.
+            allow_clusters (bool, optional) : If set to False, no clusters will be fetched. Mainly used for the option to fetch landmarks nearby.
 
         Returns:
         tuple[list[Landmark], list[Landmark]]:
         - A list of all existing landmarks.
         - A list of the most important landmarks based on the user's preferences.
         """
-        self.logger.debug('Starting to fetch landmarks...')
+        self.logger.info(f'Starting to fetch landmarks around {center_coordinates}...')
         max_walk_dist = int((preferences.max_time_minute/2)/60*self.walking_speed*1000/self.detour_factor)
-        reachable_bbox_side = min(max_walk_dist, self.max_bbox_side)
+        radius = min(max_walk_dist, int(self.max_bbox_side/2))
 
         # use set to avoid duplicates, this requires some __methods__ to be set in Landmark
         all_landmarks = set()
 
         # Create a bbox using the around technique, tuple of strings
-        bbox = tuple((min(2000, reachable_bbox_side/2), center_coordinates[0], center_coordinates[1]))
+        bbox = create_bbox(center_coordinates, radius)
 
         # list for sightseeing
         if preferences.sightseeing.score != 0:
             self.logger.debug('Fetching sightseeing landmarks...')
             current_landmarks = self.fetch_landmarks(bbox, self.amenity_selectors['sightseeing'], preferences.sightseeing.type, preferences.sightseeing.score)
             all_landmarks.update(current_landmarks)
-            self.logger.debug('Fetching sightseeing clusters...')
+            self.logger.info(f'Found {len(current_landmarks)} sightseeing landmarks')
 
+            if allow_clusters :
             # special pipeline for historic neighborhoods
-            neighborhood_manager = ClusterManager(bbox, 'sightseeing')
-            historic_clusters = neighborhood_manager.generate_clusters()
-            all_landmarks.update(historic_clusters)
-            self.logger.debug('Sightseeing clusters done')
+                neighborhood_manager = ClusterManager(bbox, 'sightseeing')
+                historic_clusters = neighborhood_manager.generate_clusters()
+                all_landmarks.update(historic_clusters)
 
         # list for nature
         if preferences.nature.score != 0:
             self.logger.debug('Fetching nature landmarks...')
             current_landmarks = self.fetch_landmarks(bbox, self.amenity_selectors['nature'], preferences.nature.type, preferences.nature.score)
             all_landmarks.update(current_landmarks)
+            self.logger.info(f'Found {len(current_landmarks)} nature landmarks')
 
 
         # list for shopping
         if preferences.shopping.score != 0:
             self.logger.debug('Fetching shopping landmarks...')
             current_landmarks = self.fetch_landmarks(bbox, self.amenity_selectors['shopping'], preferences.shopping.type, preferences.shopping.score)
-            self.logger.debug('Fetching shopping clusters...')
+            self.logger.info(f'Found {len(current_landmarks)} shopping landmarks')
 
             # set time for all shopping activites :
             for landmark in current_landmarks :
                 landmark.duration = 30
             all_landmarks.update(current_landmarks)
 
-            # special pipeline for shopping malls
-            shopping_manager = ClusterManager(bbox, 'shopping')
-            shopping_clusters = shopping_manager.generate_clusters()
-            all_landmarks.update(shopping_clusters)
-            self.logger.debug('Shopping clusters done')
+            if allow_clusters :
+                # special pipeline for shopping malls
+                shopping_manager = ClusterManager(bbox, 'shopping')
+                shopping_clusters = shopping_manager.generate_clusters()
+                all_landmarks.update(shopping_clusters)
 
 
-
-        landmarks_constrained = take_most_important(all_landmarks, self.n_important)
+        # DETAILS HERE
         # self.logger.info(f'All landmarks generated : {len(all_landmarks)} landmarks around {center_coordinates}, and constrained to {len(landmarks_constrained)} most important ones.')
+        self.logger.info(f'Found {len(all_landmarks)} landmarks in total.')
 
-        return all_landmarks, landmarks_constrained
+        return sorted(all_landmarks, key=lambda x: x.attractiveness, reverse=True)
+    
 
     def set_landmark_score(self, landmark: Landmark, landmarktype: str, preference_level: int) :
         """
@@ -154,6 +155,8 @@ class LandmarkManager:
             score *= self.wikipedia_bonus
         if landmark.is_place_of_worship :
             score *= self.church_coeff
+        if landmark.is_viewpoint :
+            score *= self.viewpoint_bonus
         if landmarktype == 'nature' :
             score *= self.nature_coeff
 
@@ -179,7 +182,7 @@ class LandmarkManager:
         """
         return_list = []
 
-        if landmarktype == 'nature' : query_conditions = []
+        if landmarktype == 'nature' : query_conditions = None
         else : query_conditions = ['count_tags()>5']
 
         # caution, when applying a list of selectors, overpass will search for elements that match ALL selectors simultaneously
@@ -190,119 +193,107 @@ class LandmarkManager:
             osm_types = ['way', 'relation']
 
             if 'viewpoint' in sel :
-                query_conditions = []
+                query_conditions = None
                 osm_types.append('node')
 
-            query = self.overpass.build_query(
-                area = bbox,
-                osm_types = osm_types,
-                selector = sel,
-                conditions = query_conditions,        # except for nature....
-                out = 'center'
-                )
-            self.logger.debug(f"Query: {query}")
-
+            # Send the overpass query
             try:
-                result = self.overpass.send_query(query)
+                result = self.overpass.send_query(
+                    bbox = bbox,
+                    osm_types = osm_types,
+                    selector = sel,
+                    conditions = query_conditions,        # except for nature....
+                    out = 'ids center tags'
+                    )
             except Exception as e:
-                self.logger.error(f"Error fetching landmarks: {e}")
+                self.logger.debug(f"Failed to fetch landmarks, proceeding without: {str(e)}")
                 continue
 
-            return_list += self.xml_to_landmarks(result, landmarktype, preference_level)
+            return_list += self._to_landmarks(result, landmarktype, preference_level)
 
-        self.logger.debug(f"Fetched {len(return_list)} landmarks of type {landmarktype} in {bbox}")
+        # self.logger.debug(f"Fetched {len(return_list)} landmarks of type {landmarktype} in {bbox}")
 
         return return_list
 
 
-    def xml_to_landmarks(self, root: ET.Element, landmarktype, preference_level) -> list[Landmark]:
+    def _to_landmarks(self, elements: list, landmarktype, preference_level) -> list[Landmark]:
         """
         Parse the Overpass API result and extract landmarks.
 
-        This method processes the XML root element returned by the Overpass API and 
+        This method processes the JSON elements returned by the Overpass API and 
         extracts landmarks of types 'node', 'way', and 'relation'. It retrieves 
         relevant information such as name, coordinates, and tags, and converts them 
         into Landmark objects.
 
         Args:
-        root (ET.Element): The root element of the XML response from Overpass API.
+        elements (list): The elements of json response from Overpass API.
         elem_type (str): The type of landmark (e.g., node, way, relation).
 
         Returns:
-        list[Landmark]: A list of Landmark objects extracted from the XML data.
+        list[Landmark]: A list of Landmark objects extracted from the JSON data.
         """
-        if root is None :
+        if elements is None :
             return []
 
         landmarks = []
-        for osm_type in ['node', 'way', 'relation'] :
-            for elem in root.findall(osm_type):
+        for elem in elements:
+            osm_type = elem.get('type')
 
-                id, coords, name = get_base_info(elem, osm_type, with_name=True)
-
-                if name is None or coords is None :
-                    continue
-
-                tags = elem.findall('tag')
-
-                # Convert this to Landmark object
-                landmark = Landmark(name=name,
-                                    type=landmarktype,
-                                    location=coords,
-                                    osm_id=id,
-                                    osm_type=osm_type,
-                                    attractiveness=0,
-                                    n_tags=len(tags))
-
-                # Browse through tags to add information to landmark.
-                for tag in tags:
-                    key = tag.get('k')
-                    value = tag.get('v')
-
-                    # Skip this landmark if not suitable.
-                    if key == 'building:part' and value == 'yes' :
-                        break
-                    if 'disused:' in key :
-                        break
-                    if 'boundary:' in key :
-                        break
-                    if 'shop' in key and landmarktype != 'shopping' :
-                        break
-                    # if value == 'apartments' :
-                    #     break
-
-                    # Fill in the other attributes.
-                    if key == 'image' :
-                        landmark.image_url = value
-                    if key == 'website' :
-                        landmark.website_url = value
-                    if key == 'place_of_worship' :
-                        landmark.is_place_of_worship = True
-                    if key == 'wikipedia' :
-                        landmark.wiki_url = value
-                    if key == 'name:en' :
-                        landmark.name_en = value
-                    if 'building:' in key or 'pay' in key :
-                        landmark.n_tags -= 1
-
-                    # Set the duration.
-                    if value in ['museum', 'aquarium', 'planetarium'] :
-                        landmark.duration = 60
-                    elif value == 'viewpoint' :
-                        landmark.is_viewpoint = True
-                        landmark.duration = 10
-                    elif value == 'cathedral' :
-                        landmark.is_place_of_worship = False
-                        landmark.duration = 10
-
-                else:
-                    self.set_landmark_score(landmark, landmarktype, preference_level)
-                    landmarks.append(landmark)
+            id, coords, name = get_base_info(elem, osm_type, with_name=True)
 
+            if name is None or coords is None :
                 continue
 
+            tags = elem.get('tags')
+            n_tags=len(tags)
+
+            # Skip this landmark if not suitable
+            if tags.get('building:part') is not None :
+                continue
+            if tags.get('disused') is not None :
+                continue
+            if tags.get('boundary') is not None :
+                continue
+            if tags.get('shop') is not None and landmarktype != 'shopping' :
+                continue
+
+            # Convert this to Landmark object
+            landmark = Landmark(name=name,
+                                type=landmarktype,
+                                location=coords,
+                                osm_id=id,
+                                osm_type=osm_type,
+                                attractiveness=0,
+                                n_tags=n_tags)
+
+            # Extract useful information for score calculation later down the road.
+            landmark.image_url = tags.get('image')
+            landmark.website_url = tags.get('website')
+            landmark.wiki_url = tags.get('wikipedia')
+            landmark.name_en = tags.get('name:en')
+
+            # Check for place of worship
+            if tags.get('place_of_worship') is not None :
+                    landmark.is_place_of_worship = True
+                    landmark.name_en = tags.get('place_of_worship')
+
+            # Set the duration. Needed for the optimization.
+            if tags.get('amenity') in ['aquarium', 'planetarium'] or tags.get('tourism') in ['aquarium', 'museum', 'zoo']:
+                landmark.duration = 60
+            elif tags.get('tourism') == 'viewpoint' :
+                landmark.is_viewpoint = True
+                landmark.duration = 10
+            elif tags.get('building') == 'cathedral' :
+                landmark.is_place_of_worship = False
+                landmark.duration = 10
+
+            # Compute the score and add landmark to the list.
+            self.set_landmark_score(landmark, landmarktype, preference_level)
+            landmarks.append(landmark)
+
         return landmarks
 
+
 def dict_to_selector_list(d: dict) -> list:
     """
     Convert a dictionary of key-value pairs to a list of Overpass query strings.

backend/src/landmarks/landmarks_router.py

@@ -0,0 +1,123 @@
+"""Main app for backend api"""
+import logging
+import time
+import random
+from fastapi import HTTPException, APIRouter
+
+from ..structs.landmark import Landmark
+from ..structs.preferences import Preferences, Preference
+from .landmarks_manager import LandmarkManager
+
+
+# Setup the logger and the Landmarks Manager
+logger = logging.getLogger(__name__)
+manager = LandmarkManager()
+
+
+# Initialize the API router
+router = APIRouter()
+
+
+@router.post("/get/landmarks")
+def get_landmarks(
+    preferences: Preferences,
+    start: tuple[float, float],
+) -> list[Landmark]:
+    """
+    Function that returns all available landmarks given some preferences and a start position.
+
+    Args:
+        preferences : the preferences specified by the user as the post body
+        start       : the coordinates of the starting point
+    Returns: 
+        list[Landmark] : The full list of fetched landmarks
+    """
+    if preferences is None:
+        raise HTTPException(status_code=406, detail="Preferences not provided or incomplete.")
+    if (preferences.shopping.score == 0 and
+        preferences.sightseeing.score == 0 and
+        preferences.nature.score == 0) :
+        raise HTTPException(status_code=406, detail="All preferences are 0.")
+    if start is None:
+        raise HTTPException(status_code=406, detail="Start coordinates not provided")
+    if not (-90 <= start[0] <= 90 or -180 <= start[1] <= 180):
+        raise HTTPException(status_code=422, detail="Start coordinates not in range")
+
+    logger.info(f"Requested new trip generation. Details:\n\tCoordinates: {start}\n\tTime: {preferences.max_time_minute}\n\tSightseeing: {preferences.sightseeing.score}\n\tNature: {preferences.nature.score}\n\tShopping: {preferences.shopping.score}")
+
+    start_time = time.time()
+
+    # Generate the landmarks from the start location
+    landmarks = manager.generate_landmarks_list(
+        center_coordinates = start,
+        preferences = preferences
+    )
+
+    if len(landmarks) == 0 :
+        raise HTTPException(status_code=500, detail="No landmarks were found.")
+
+    t_generate_landmarks = time.time() - start_time
+    logger.info(f'Fetched {len(landmarks)} landmarks in  \t: {round(t_generate_landmarks,3)} seconds')
+    
+    return landmarks
+
+
+@router.post("/get-nearby/landmarks/{lat}/{lon}")
+def get_landmarks_nearby(
+    lat: float,
+    lon: float
+) -> list[Landmark] :
+    """
+    Suggests nearby landmarks based on a given latitude and longitude.
+
+    This endpoint returns a curated list of up to 5 landmarks around the given geographical coordinates. It uses fixed preferences for
+    sightseeing, shopping, and nature, with a maximum time constraint of 30 minutes to limit the number of landmarks returned.
+
+    Args:
+        lat (float): Latitude of the user's current location.
+        lon (float): Longitude of the user's current location.
+
+    Returns:
+        list[Landmark]: A list of selected nearby landmarks.
+    """
+    logger.info(f'Fetching landmarks nearby ({lat}, {lon}).')
+
+    # Define fixed preferences:
+    prefs = Preferences(
+        sightseeing = Preference(
+            type='sightseeing',
+            score=5
+        ),
+        shopping = Preference(
+            type='shopping',
+            score=2
+        ),
+        nature = Preference(
+            type='nature',
+            score=5
+        ),
+        max_time_minute=30,
+        detour_tolerance_minute=0,
+    )
+
+    # Find the landmarks around the location
+    landmarks_around = manager.generate_landmarks_list(
+        center_coordinates = (lat, lon),
+        preferences = prefs,
+        allow_clusters=False,
+    )
+
+    if len(landmarks_around) == 0 :
+        raise HTTPException(status_code=500, detail="No landmarks were found.")
+
+    # select 8 - 12 landmarks from there
+    if len(landmarks_around) > 8 :
+        n_imp = random.randint(2,5)
+        rest = random.randint(8 - n_imp, min(12, len(landmarks_around))-n_imp)
+
+        print(f'len = {len(landmarks_around)}\nn_imp = {n_imp}\nrest = {rest}')
+        landmarks_around = landmarks_around[:n_imp] + random.sample(landmarks_around[n_imp:], rest)
+    
+    logger.info(f'Found {len(landmarks_around)} landmarks to suggest nearby ({lat}, {lon}).')
+    # logger.debug('Suggested landmarks :\n\t' + '\n\t'.join(f'{landmark}' for landmark in landmarks_around))
+    return landmarks_around

backend/src/logging_config.py

@@ -33,14 +33,14 @@ def configure_logging():
         # silence the chatty logs loki generates itself
         logging.getLogger('urllib3.connectionpool').setLevel(logging.WARNING)
         # no need for time since it's added by loki or can be shown in kube logs
-        logging_format = '%(name)s - %(levelname)s - %(message)s'
+        logging_format = '%(name)-55s - %(levelname)-7s - %(message)s'
 
     else:
         # if we are in a debug (local) session, set verbose and rich logging
         from rich.logging import RichHandler
         logging_handlers = [RichHandler()]
         logging_level = logging.DEBUG if is_debug else logging.INFO
-        logging_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        logging_format = '%(asctime)s - %(name)-55s - %(levelname)-7s - %(message)s'
 
 
 

backend/src/main.py

@@ -1,21 +1,22 @@
 """Main app for backend api"""
-
 import logging
-import time
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, HTTPException, Query
+from fastapi import FastAPI, HTTPException
 
 from .logging_config import configure_logging
-from .structs.landmark import Landmark, Toilets
-from .structs.preferences import Preferences
+from .structs.landmark import Landmark
 from .structs.linked_landmarks import LinkedLandmarks
 from .structs.trip import Trip
-from .utils.landmarks_manager import LandmarkManager
-from .utils.toilets_manager import ToiletsManager
+from .landmarks.landmarks_manager import LandmarkManager
+from .toilets.toilets_router import router as toilets_router
+from .optimization.optimization_router import router as optimization_router
+from .landmarks.landmarks_router import router as landmarks_router
+from .payments.payment_router import router as payment_router
 from .optimization.optimizer import Optimizer
 from .optimization.refiner import Refiner
 from .cache import client as cache_client
 
+
 logger = logging.getLogger(__name__)
 
 manager = LandmarkManager()
@@ -36,99 +37,24 @@ app = FastAPI(lifespan=lifespan)
 
 
 
-@app.post("/trip/new")
-def new_trip(preferences: Preferences,
-             start: tuple[float, float],
-             end: tuple[float, float] | None = None) -> Trip:
-    """
-    Main function to call the optimizer.
+# Fetches the global list of landmarks given preferences and start/end coordinates. Two routes
+# Call with "/get/landmarks/" for main entry point of the trip generation pipeline.
+# Call with "/get-nearby/landmarks/" for the NEARBY feature.
+app.include_router(landmarks_router)
 
-    Args:
-        preferences : the preferences specified by the user as the post body
-        start       : the coordinates of the starting point
-        end         : the coordinates of the finishing point
-    Returns: 
-        (uuid) : The uuid of the first landmark in the optimized route
-    """
-    if preferences is None:
-        raise HTTPException(status_code=406, detail="Preferences not provided or incomplete.")
-    if (preferences.shopping.score == 0 and
-        preferences.sightseeing.score == 0 and
-        preferences.nature.score == 0) :
-        raise HTTPException(status_code=406, detail="All preferences are 0.")
-    if start is None:
-        raise HTTPException(status_code=406, detail="Start coordinates not provided")
-    if not (-90 <= start[0] <= 90 or -180 <= start[1] <= 180):
-        raise HTTPException(status_code=422, detail="Start coordinates not in range")
-    if end is None:
-        end = start
-        logger.info("No end coordinates provided. Using start=end.")
 
-    start_landmark = Landmark(name='start',
-                              type='start',
-                              location=(start[0], start[1]),
-                              osm_type='start',
-                              osm_id=0,
-                              attractiveness=0,
-                              duration=0,
-                              must_do=True,
-                              n_tags = 0)
+# Optimizes the trip given preferences. Second step in the main trip generation pipeline.
+# Call with "/optimize/trip"
+app.include_router(optimization_router)
 
-    end_landmark = Landmark(name='finish',
-                            type='finish',
-                            location=(end[0], end[1]),
-                            osm_type='end',
-                            osm_id=0,
-                            attractiveness=0,
-                            duration=0,
-                            must_do=True,
-                            n_tags=0)
 
-    start_time = time.time()
-    # Generate the landmarks from the start location
-    landmarks, landmarks_short = manager.generate_landmarks_list(
-        center_coordinates = start,
-        preferences = preferences
-    )
-
-    # insert start and finish to the landmarks list
-    landmarks_short.insert(0, start_landmark)
-    landmarks_short.append(end_landmark)
-
-    t_generate_landmarks = time.time() - start_time
-    logger.info(f'Fetched {len(landmarks)} landmarks in  \t: {round(t_generate_landmarks,3)} seconds')
-    start_time = time.time()
-
-    # First stage optimization
-    try:
-        base_tour = optimizer.solve_optimization(preferences.max_time_minute, landmarks_short)
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Optimization failed: {str(exc)}") from exc
-
-    t_first_stage = time.time() - start_time
-    start_time = time.time()
-
-    # Second stage optimization
-    # TODO : only if necessary (not enough landmarks for ex.)
-    try :
-        refined_tour = refiner.refine_optimization(landmarks, base_tour,
-                                               preferences.max_time_minute,
-                                               preferences.detour_tolerance_minute)
-    except Exception as exc :
-        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(exc)}") from exc
-
-    t_second_stage = time.time() - start_time
-
-    logger.debug(f'First stage optimization\t: {round(t_first_stage,3)} seconds')
-    logger.debug(f'Second stage optimization\t: {round(t_second_stage,3)} seconds')
-    logger.info(f'Total computation time\t: {round(t_first_stage + t_second_stage,3)} seconds')
-
-    linked_tour = LinkedLandmarks(refined_tour)
-    # upon creation of the trip, persistence of both the trip and its landmarks is ensured.
-    trip = Trip.from_linked_landmarks(linked_tour, cache_client)
-    logger.info(f'Generated a trip of {trip.total_time} minutes with {len(refined_tour)} landmarks in {round(t_generate_landmarks + t_first_stage + t_second_stage,3)} seconds.')
-    return trip
+# Fetches toilets near given coordinates.
+# Call with "/get/toilets" for fetching toilets around coordinates.
+app.include_router(toilets_router)
 
+# Include the payment router for interacting with paypal sdk.
+# See src/payment/payment_router.py for more information on how to call.
+app.include_router(payment_router)
 
 #### For already existing trips/landmarks
 @app.get("/trip/{trip_uuid}")
@@ -146,6 +72,7 @@ def get_trip(trip_uuid: str) -> Trip:
         trip = cache_client.get(f"trip_{trip_uuid}")
         return trip
     except KeyError as exc:
+        logger.error(f"Failed to fetch trip with UUID {trip_uuid}: {str(exc)}")
         raise HTTPException(status_code=404, detail="Trip not found") from exc
 
 
@@ -164,32 +91,46 @@ def get_landmark(landmark_uuid: str) -> Landmark:
         landmark = cache_client.get(f"landmark_{landmark_uuid}")
         return landmark
     except KeyError as exc:
+        logger.error(f"Failed to fetch landmark with UUID {landmark_uuid}: {str(exc)}")
         raise HTTPException(status_code=404, detail="Landmark not found") from exc
 
 
-@app.post("/toilets/new")
-def get_toilets(location: tuple[float, float] = Query(...), radius: int = 500) -> list[Toilets] :
+@app.post("/trip/recompute-time/{trip_uuid}/{removed_landmark_uuid}")
+def update_trip_time(trip_uuid: str, removed_landmark_uuid: str) -> Trip:
     """
-    Endpoint to find toilets within a specified radius from a given location.
-
-    This endpoint expects the `location` and `radius` as **query parameters**, not in the request body.
+    Updates the reaching times of a given trip when removing a landmark.
 
     Args:
-        location (tuple[float, float]): The latitude and longitude of the location to search from.
-        radius (int, optional): The radius (in meters) within which to search for toilets. Defaults to 500 meters.
+        landmark_uuid (str) : unique identifier for a Landmark.
 
     Returns:
-        list[Toilets]: A list of Toilets objects that meet the criteria.
+        (Landmark)          : the corresponding Landmark.
     """
-    if location is None:
-        raise HTTPException(status_code=406, detail="Coordinates not provided or invalid")
-    if not (-90 <= location[0] <= 90 or -180 <= location[1] <= 180):
-        raise HTTPException(status_code=422, detail="Start coordinates not in range")
-
-    toilets_manager = ToiletsManager(location, radius)
-
-    try :
-        toilets_list = toilets_manager.generate_toilet_list()
-        return toilets_list
+    # First, fetch the trip in the cache.
+    try:
+        trip = cache_client.get(f'trip_{trip_uuid}')
     except KeyError as exc:
-        raise HTTPException(status_code=404, detail="No toilets found") from exc
+        logger.error(f"Failed to update trip with UUID {trip_uuid} (trip not found): {str(exc)}")
+        raise HTTPException(status_code=404, detail='Trip not found') from exc
+
+    landmarks = []
+    next_uuid = trip.first_landmark_uuid
+
+    # Extract landmarks
+    try :
+        while next_uuid is not None:
+            landmark = cache_client.get(f'landmark_{next_uuid}')
+            # Filter out the removed landmark.
+            if next_uuid != removed_landmark_uuid :
+                landmarks.append(landmark)
+            next_uuid = landmark.next_uuid  # Prepare for the next iteration
+    except KeyError as exc:
+        logger.error(f"Failed to update trip with UUID {trip_uuid} : {str(exc)}")
+        raise HTTPException(status_code=404, detail=f'landmark {next_uuid} not found') from exc
+
+    # Re-link every thing and compute times again
+    linked_tour = LinkedLandmarks(landmarks)
+    trip = Trip.from_linked_landmarks(linked_tour, cache_client)
+
+    return trip
+

backend/src/optimization/optimization_router.py

@@ -0,0 +1,164 @@
+"""API entry point for the trip optimization."""
+
+import logging
+import time
+import yaml
+from fastapi import HTTPException, APIRouter, BackgroundTasks, Body
+
+from .optimizer import Optimizer
+from .refiner import Refiner
+from ..supabase.supabase import SupabaseClient
+from ..structs.landmark import Landmark
+from ..structs.preferences import Preferences
+from ..structs.linked_landmarks import LinkedLandmarks
+from ..structs.trip import Trip
+from ..overpass.overpass import fill_cache
+from ..cache import client as cache_client
+from ..constants import OPTIMIZER_PARAMETERS_PATH
+
+
+# Setup the Logger, Optimizer and Refiner
+logger = logging.getLogger(__name__)
+optimizer = Optimizer()
+refiner = Refiner(optimizer=optimizer)
+supabase = SupabaseClient()
+
+
+# Initialize the API router
+router = APIRouter()
+
+
+@router.post("/optimize/trip")
+def optimize_trip(
+        user_id: str = Body(...),
+        preferences: Preferences = Body(...),
+        landmarks: list[Landmark] = Body(...),
+        start: tuple[float, float] = Body(...),
+        end: tuple[float, float] | None = Body(None),
+        background_tasks: BackgroundTasks = None
+    ) -> Trip:
+    """
+    Main function to call the optimizer.
+
+    Args:
+        preferences (Preferences)   : the preferences specified by the user as the post body.
+        start (tuple[float, float]) : the coordinates of the starting point.
+        end tuple[float, float]     : the coordinates of the finishing point.
+        backgroud_tasks (BackgroundTasks) : necessary to fill the cache after the trip has been returned.
+    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.')
+            raise HTTPException(status_code=418, detail='Insufficient credits')
+    except SyntaxError as se :
+        logger.error(f'SyntaxError: {se}')
+        raise HTTPException(status_code=400, detail=str(se)) from se
+    except ValueError as ve :
+        logger.error(f'SyntaxError: {ve}')
+        raise HTTPException(status_code=406, detail=str(ve)) from ve
+    except Exception as exc:
+        logger.error(f'SyntaxError: {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 len(landmarks) == 0 :
+        raise HTTPException(status_code=406, detail="No landmarks provided for computing the trip.")
+    if (preferences.shopping.score == 0 and
+        preferences.sightseeing.score == 0 and
+        preferences.nature.score == 0) :
+        raise HTTPException(status_code=406, detail="All preferences are 0.")
+    if start is None:
+        raise HTTPException(status_code=406, detail="Start coordinates not provided")
+    if not (-90 <= start[0] <= 90 or -180 <= start[1] <= 180):
+        raise HTTPException(status_code=422, detail="Start coordinates not in range")
+    if end is None:
+        end = start
+        logger.info("No end coordinates provided. Using start=end.")
+
+    # Start the timer
+    start_time = time.time()
+
+    logger.info(f"Requested new trip generation. Details:\n\tCoordinates: {start}\n\tTime: {preferences.max_time_minute}\n\tSightseeing: {preferences.sightseeing.score}\n\tNature: {preferences.nature.score}\n\tShopping: {preferences.shopping.score}")
+
+    start_landmark = Landmark(
+        name='start',
+        type='start',
+        location=(start[0], start[1]),
+        osm_type='start',
+        osm_id=0,
+        attractiveness=0,
+        duration=0,
+        must_do=True,
+        n_tags = 0
+    )
+
+    end_landmark = Landmark(
+        name='finish',
+        type='finish',
+        location=(end[0], end[1]),
+        osm_type='end',
+        osm_id=0,
+        attractiveness=0,
+        duration=0,
+        must_do=True,
+        n_tags=0
+    )
+    
+    # From the parameters load the length at which to truncate the landmarks list.
+    with OPTIMIZER_PARAMETERS_PATH.open('r') as f:
+            parameters = yaml.safe_load(f)
+            n_important = parameters['N_important']
+
+    # Truncate to the  most important landmarks for a shorter list
+    landmarks_short = landmarks[:n_important]
+
+    # insert start and finish to the shorter landmarks list
+    landmarks_short.insert(0, start_landmark)
+    landmarks_short.append(end_landmark)
+
+    # First stage optimization
+    try:
+        base_tour = optimizer.solve_optimization(preferences.max_time_minute, landmarks_short)
+    except Exception as exc:
+        logger.error(f"Trip generation failed: {str(exc)}")
+        raise HTTPException(status_code=500, detail=f"Optimization failed: {str(exc)}") from exc
+
+    t_first_stage = time.time() - start_time
+    start_time = time.time()
+
+    # Second stage optimization
+    try :
+        refined_tour = refiner.refine_optimization(
+            landmarks, base_tour,
+            preferences.max_time_minute,
+            preferences.detour_tolerance_minute
+        )
+    except Exception as exc :
+        logger.warning(f"Refiner failed. Proceeding with base trip {str(exc)}")
+        refined_tour = base_tour
+
+    t_second_stage = time.time() - start_time
+
+    logger.debug(f'First stage optimization\t: {round(t_first_stage,3)} seconds')
+    logger.debug(f'Second stage optimization\t: {round(t_second_stage,3)} seconds')
+    logger.info(f'Total computation time\t: {round(t_first_stage + t_second_stage,3)} seconds')
+    linked_tour = LinkedLandmarks(refined_tour)
+
+    # upon creation of the trip, persistence of both the trip and its landmarks is ensured.
+    trip = Trip.from_linked_landmarks(linked_tour, cache_client)
+    logger.info(f'Optimized a trip of {trip.total_time} minutes with {len(refined_tour)} landmarks in {round(t_first_stage + t_second_stage,3)} seconds.')
+    logger.info('Detailed trip :\n\t' + '\n\t'.join(f'{landmark}' for landmark in refined_tour))
+
+    # Add the cache fill as background task
+    background_tasks.add_task(fill_cache)
+
+    # Finally, decrement the user balance
+    supabase.decrement_credit_balance(user_id=user_id)
+
+    return trip
+

backend/src/optimization/optimizer.py

@@ -55,6 +55,9 @@ class Optimizer:
             self.average_walking_speed = parameters['average_walking_speed']
             self.max_landmarks = parameters['max_landmarks']
             self.overshoot = parameters['overshoot']
+            self.time_limit = parameters['time_limit']
+            self.gap_rel = parameters['gap_rel']
+            self.max_iter = parameters['max_iter']
 
 
     def init_ub_time(self, prob: pl.LpProblem, x: pl.LpVariable, L: int, landmarks: list[Landmark], max_time: int):
@@ -254,7 +257,6 @@ class Optimizer:
         Returns:
             None: This function modifies the `prob` object by adding L-2 equality constraints in-place.
         """
-        # FIXME: weird 0 artifact in the coefficients popping up
         # Loop through rows 1 to L-2 to prevent stacked ones
         for i in range(1, L-1):
             # Add the constraint that sums across each "row" or "block" in the decision variables
@@ -490,10 +492,21 @@ class Optimizer:
 
 
     def warm_start(self, x: list[pl.LpVariable], L: int) :
+        """
+        This function sets the initial values of the decision variables to a feasible solution.
+        This can help the solver start with a feasible or heuristic solution,
+        potentially speeding up convergence.
 
+        Args:
+        x (list[pl.LpVariable]): A list of PuLP decision variables (binary variables).
+        L (int): The size parameter, representing a dimension (likely related to a grid or matrix).
+
+        Returns:
+        list[pl.LpVariable]: The modified list of PuLP decision variables with initial values set.
+        """
         for i in range(L*L) :
             x[i].setInitialValue(0)
-            
+
         x[1].setInitialValue(1)
         x[2*L-1].setInitialValue(1)
 
@@ -573,37 +586,44 @@ class Optimizer:
         prob, x = self.pre_processing(L, landmarks, max_time, max_landmarks)
 
         # Solve the problem and extract results.
-        prob.solve(pl.PULP_CBC_CMD(msg=False, gapRel=0.1, timeLimit=10, warmStart=False))
+        try :
+            prob.solve(pl.PULP_CBC_CMD(msg=False, timeLimit=self.time_limit+1, gapRel=self.gap_rel))
+        except Exception as exc :
+            raise Exception(f"No solution found: {str(exc)}") from exc
         status = pl.LpStatus[prob.status]
         solution = [pl.value(var) for var in x]  # The values of the decision variables (will be 0 or 1)
 
-        self.logger.debug("First results are out. Looking out for circles and correcting.")
+        self.logger.debug("First results are out. Looking out for circles and correcting...")
 
         # Raise error if no solution is found. FIXME: for now this throws the internal server error
         if status != 'Optimal' :
-            self.logger.error("The problem is overconstrained, no solution on first try.")
+            self.logger.warning("The problem is overconstrained, no solution on first try.")
             raise ArithmeticError("No solution could be found. Please try again with more time or different preferences.")
 
         # If there is a solution, we're good to go, just check for connectiveness
         circles = self.is_connected(solution)
 
         i = 0
-        timeout = 40
         while circles is not None :
             i += 1
-            if i == timeout :
-                self.logger.error(f'Timeout: No solution found after {timeout} iterations.')
-                raise TimeoutError(f"Optimization took too long. No solution found after {timeout} iterations.")
+            if i == self.max_iter :
+                self.logger.warning(f'Timeout: No solution found after {self.max_iter} iterations.')
+                raise TimeoutError(f"Optimization took too long. No solution found after {self.max_iter} iterations.")
 
             for circle in circles :
                 self.prevent_circle(prob, x, circle, L)
 
             # Solve the problem again
-            prob.solve(pl.PULP_CBC_CMD(msg=False))
+            try :
+                prob.solve(pl.PULP_CBC_CMD(msg=False, timeLimit=self.time_limit, gapRel=self.gap_rel))
+            except Exception as exc :
+                self.logger.warning("No solution found: {str(exc)")
+                raise Exception(f"No solution found: {str(exc)}") from exc
+
             solution = [pl.value(var) for var in x]
 
             if pl.LpStatus[prob.status] != 'Optimal' :
-                self.logger.error("The problem is overconstrained, no solution after {i} cycles.")
+                self.logger.warning("The problem is overconstrained, no solution after {i} cycles.")
                 raise ArithmeticError("No solution could be found. Please try again with more time or different preferences.")
 
             circles = self.is_connected(solution)
@@ -614,5 +634,5 @@ class Optimizer:
         order = self.get_order(solution)
         tour =  [landmarks[i] for i in order]
 
-        self.logger.debug(f"Re-optimized {i} times, objective value : {int(pl.value(prob.objective))}")
+        self.logger.info(f"Re-optimized {i} times, objective value : {int(pl.value(prob.objective))}")
         return tour

backend/src/optimization/refiner.py

@@ -6,7 +6,6 @@ from shapely import buffer, LineString, Point, Polygon, MultiPoint, concave_hull
 
 from ..structs.landmark import Landmark
 from ..utils.get_time_distance import get_time
-from ..utils.take_most_important import take_most_important
 from .optimizer import Optimizer
 from ..constants import OPTIMIZER_PARAMETERS_PATH
 
@@ -238,7 +237,7 @@ class Refiner :
             if self.is_in_area(area, landmark.location) and landmark.name not in visited_names:
                 second_order_landmarks.append(landmark)
 
-        return take_most_important(second_order_landmarks, int(self.max_landmarks_refiner*0.75))
+        return sorted(second_order_landmarks, key=lambda x: x.attractiveness, reverse=True)[:int(self.max_landmarks_refiner*0.75)]
 
 
     # Try fix the shortest path using shapely
@@ -278,7 +277,7 @@ class Refiner :
             better_tour_poly = concave_hull(MultiPoint(coords))  # Create concave hull with "core" of tour leaving out start and finish
             xs, ys = better_tour_poly.exterior.xy
             """ 
-            ERROR HERE : 
+            FIXED : ERROR HERE : 
                 Exception has occurred: AttributeError
                 'LineString' object has no attribute 'exterior'
             """
@@ -356,7 +355,7 @@ class Refiner :
 
         # If unsuccessful optimization, use the base_tour.
         if new_tour is None:
-            self.logger.warning("No solution found for the refined tour. Returning the initial tour.")
+            self.logger.warning("Refiner failed: No solution found during second stage optimization.")
             new_tour = base_tour
 
         # If only one landmark, return it.
@@ -369,6 +368,7 @@ class Refiner :
         # Fix the tour using Polygons if the path looks weird.
         # Conditions : circular trip and invalid polygon.
         if base_tour[0].location == base_tour[-1].location and not better_poly.is_valid :
+            self.logger.debug("Tours might be funky, attempting to correct with polygons")
             better_tour = self.fix_using_polygon(better_tour)
 
         return better_tour

backend/src/overpass/caching_strategy.py

@@ -1,9 +1,9 @@
-"""Module defining the caching strategy for overpass requests."""
+"""Module defining the handling of cache data from Overpass requests."""
 import os
-import xml.etree.ElementTree as ET
+import json
 import hashlib
 
-from ..constants import OSM_CACHE_DIR
+from ..constants import OSM_CACHE_DIR, OSM_TYPES
 
 
 def get_cache_key(query: str) -> str:
@@ -17,10 +17,6 @@ def get_cache_key(query: str) -> str:
 class CachingStrategyBase:
     """
     Base class for implementing caching strategies.
-
-    This class defines the structure for a caching strategy with basic methods
-    that must be implemented by subclasses. Subclasses should define how to
-    retrieve, store, and close the cache.
     """
     def get(self, key):
         """Retrieve the cached data associated with the provided key."""
@@ -30,111 +26,111 @@ class CachingStrategyBase:
         """Store data in the cache with the specified key."""
         raise NotImplementedError('Subclass should implement set')
 
+    def set_hollow(self, key, **kwargs):
+        """Create a hollow (empty) cache entry with a specific key."""
+        raise NotImplementedError('Subclass should implement set_hollow')
+
     def close(self):
         """Clean up or close any resources used by the caching strategy."""
 
 
-class XMLCache(CachingStrategyBase):
+class JSONCache(CachingStrategyBase):
     """
-    A caching strategy that stores and retrieves data in XML format.
-
-    This class provides methods to cache data as XML files in a specified directory.
-    The directory is automatically suffixed with '_XML' to distinguish it from other
-    caching strategies. The data is stored and retrieved using XML serialization.
-
-    Args:
-        cache_dir (str): The base directory where XML cache files will be stored.
-                         Defaults to 'OSM_CACHE_DIR' with a '_XML' suffix.
-
-    Methods:
-        get(key): Retrieve cached data from a XML file associated with the given key.
-        set(key, value): Store data in a XML file with the specified key.
+    A caching strategy that stores and retrieves data in JSON format.
     """
     def __init__(self, cache_dir=OSM_CACHE_DIR):
         # Add the class name as a suffix to the directory
-        self._cache_dir = f'{cache_dir}_XML'
+        self._cache_dir = f'{cache_dir}'
         if not os.path.exists(self._cache_dir):
             os.makedirs(self._cache_dir)
 
     def _filename(self, key):
-        return os.path.join(self._cache_dir, f'{key}.xml')
+        return os.path.join(self._cache_dir, f'{key}.json')
 
     def get(self, key):
-        """Retrieve XML data from the cache and parse it as an ElementTree."""
+        """Retrieve JSON data from the cache and parse it as an ElementTree."""
         filename = self._filename(key)
         if os.path.exists(filename):
             try:
-                # Parse and return the cached XML data
-                tree = ET.parse(filename)
-                return tree.getroot()  # Return the root element of the parsed XML
-            except ET.ParseError:
-                # print(f"Error parsing cached XML file: {filename}")
-                return None
+                # Open and parse the cached JSON data
+                with open(filename, 'r', encoding='utf-8') as file:
+                    data = json.load(file)
+                # Return the data as a list of dicts.
+                return data
+            except json.JSONDecodeError:
+                return None  # Return None if parsing fails
         return None
 
     def set(self, key, value):
-        """Save the XML data as an ElementTree to the cache."""
+        """Save the JSON data in the cache."""
         filename = self._filename(key)
-        tree = ET.ElementTree(value)  # value is expected to be an ElementTree root element
         try:
-            # Write the XML data to a file
-            with open(filename, 'wb') as file:
-                tree.write(file, encoding='utf-8', xml_declaration=True)
+            # Write the JSON data to the cache file
+            with open(filename, 'w', encoding='utf-8') as file:
+                json.dump(value, file, ensure_ascii=False, indent=4)
         except IOError as e:
             raise IOError(f"Error writing to cache file: {filename} - {e}") from e
 
+    def set_hollow(self, key, cell: tuple, osm_types: list,
+                    selector: str, conditions: list=None, out='center'):
+        """Create an empty placeholder cache entry for a future fill."""
+        hollow_key = f'hollow_{key}'
+        filename = self._filename(hollow_key)
+
+        # Create the hollow JSON structure
+        hollow_data = {
+            "key": key,
+            "cell": list(cell),
+            "osm_types": list(osm_types),
+            "selector": selector,
+            "conditions": conditions,
+            "out": out
+        }
+        # Write the hollow data to the cache file
+        try:
+            with open(filename, 'w', encoding='utf-8') as file:
+                json.dump(hollow_data, file, ensure_ascii=False, indent=4)
+        except IOError as e:
+            raise IOError(f"Error writing hollow cache to file: {filename} - {e}") from e
+
+    def close(self):
+        """Cleanup method, if needed."""
+
 
 class CachingStrategy:
     """
     A class to manage different caching strategies.
-
-    This class provides an interface to switch between different caching strategies 
-    (e.g., XMLCache, JSONCache) dynamically. It allows caching data in different formats, 
-    depending on the strategy being used. By default, it uses the XMLCache strategy.
-
-    Attributes:
-    __strategy (CachingStrategyBase): The currently active caching strategy.
-    __strategies (dict): A mapping between strategy names (as strings) and their corresponding
-                         classes, allowing dynamic selection of caching strategies.
     """
-    __strategy = XMLCache()  # Default caching strategy
+    __strategy = JSONCache()  # Default caching strategy
     __strategies = {
-        'XML': XMLCache,
+        'JSON': JSONCache,
     }
 
     @classmethod
-    def use(cls, strategy_name='XML', **kwargs):
-        """
-        Set the caching strategy based on the strategy_name provided.
-
-        Args:
-            strategy_name (str): The name of the caching strategy (e.g., 'XML').
-            **kwargs: Additional keyword arguments to pass when initializing the strategy.
-        """
-        # If a previous strategy exists, close it
+    def use(cls, strategy_name='JSON', **kwargs):
+        """Define the caching strategy to use."""
         if cls.__strategy:
             cls.__strategy.close()
 
-        # Retrieve the strategy class based on the strategy name
         strategy_class = cls.__strategies.get(strategy_name)
-
         if not strategy_class:
             raise ValueError(f"Unknown caching strategy: {strategy_name}")
 
-        # Instantiate the new strategy with the provided arguments
         cls.__strategy = strategy_class(**kwargs)
         return cls.__strategy
 
     @classmethod
     def get(cls, key):
-        """Get data from the current strategy's cache."""
-        if not cls.__strategy:
-            raise RuntimeError("Caching strategy has not been set.")
+        """Get the data from the cache."""
         return cls.__strategy.get(key)
 
     @classmethod
     def set(cls, key, value):
-        """Set data in the current strategy's cache."""
-        if not cls.__strategy:
-            raise RuntimeError("Caching strategy has not been set.")
+        """Save the data in the cache."""
         cls.__strategy.set(key, value)
+
+    @classmethod
+    def set_hollow(cls, key, cell: tuple, osm_types: OSM_TYPES,
+                    selector: str, conditions: list=None, out='center'):
+        """Create a hollow cache entry."""
+        cls.__strategy.set_hollow(key, cell, osm_types, selector, conditions, out)

backend/src/overpass/overpass.py

@@ -1,14 +1,18 @@
 """Module allowing connexion to overpass api and fectch data from OSM."""
-from typing import Literal, List
+import os
+import time
 import urllib
+import math
 import logging
-import xml.etree.ElementTree as ET
+import json
+from typing import List, Tuple
 
 from .caching_strategy import get_cache_key, CachingStrategy
-from ..constants import OSM_CACHE_DIR
+from ..constants import OSM_CACHE_DIR, OSM_TYPES, BBOX
 
-logger = logging.getLogger('Overpass')
-osm_types = List[Literal['way', 'node', 'relation']]
+
+RESOLUTION = 0.05
+CELL = Tuple[int, int]
 
 
 class Overpass :
@@ -16,7 +20,10 @@ class Overpass :
     Overpass class to manage the query building and sending to overpass api.
     The caching strategy is a part of this class and initialized upon creation of the Overpass object.
     """
-    def __init__(self, caching_strategy: str = 'XML', cache_dir: str = OSM_CACHE_DIR) :
+    logger = logging.getLogger(__name__)
+
+
+    def __init__(self, caching_strategy: str = 'JSON', cache_dir: str = OSM_CACHE_DIR) :
         """
         Initialize the Overpass instance with the url, headers and caching strategy.
         """
@@ -25,17 +32,110 @@ class Overpass :
         self.caching_strategy = CachingStrategy.use(caching_strategy, cache_dir=cache_dir)
 
 
-    @classmethod
-    def build_query(self, area: tuple, osm_types: osm_types,
-                    selector: str, conditions=[], out='center') -> str:
+    def send_query(self, bbox: BBOX, osm_types: OSM_TYPES,
+                    selector: str, conditions: list=None, out='center') -> List[dict]:
+        """
+        Sends the Overpass QL query to the Overpass API and returns the parsed json response.
+
+        Args:
+            bbox (tuple): Bounding box for the query.
+            osm_types (list[str]): List of OSM element types (e.g., 'node', 'way').
+            selector (str): Key or tag to filter OSM elements (e.g., 'highway').
+            conditions (list): Optional list of additional filter conditions in Overpass QL format.
+            out (str): Output format ('center', 'body', etc.). Defaults to 'center'.
+
+        Returns:
+            list:   Parsed json response from the Overpass API, or cached data if available.
+        """
+        # Determine which grid cells overlap with this bounding box.
+        overlapping_cells = Overpass._get_overlapping_cells(bbox)
+
+        # Retrieve cached data and identify missing cache entries
+        cached_responses, non_cached_cells = self._retrieve_cached_data(overlapping_cells, osm_types, selector, conditions, out)
+
+        self.logger.debug(f'Cache hit for {len(overlapping_cells)-len(non_cached_cells)}/{len(overlapping_cells)} quadrants.')
+
+        # If there is no missing data, return the cached responses after filtering.
+        if not non_cached_cells :
+            return Overpass._filter_landmarks(cached_responses, bbox)
+
+        # If there is no cached data, fetch all from Overpass.
+        if not cached_responses :
+            query_str = Overpass.build_query(bbox, osm_types, selector, conditions, out)
+            self.logger.debug(f'Query string: {query_str}')
+            return self.fetch_data_from_api(query_str)
+
+        # Resize the bbox for smaller search area and build new query string.
+        non_cached_bbox = Overpass._get_non_cached_bbox(non_cached_cells, bbox)
+        query_str = Overpass.build_query(non_cached_bbox, osm_types, selector, conditions, out)
+        self.logger.debug(f'Query string: {query_str}')
+        non_cached_responses = self.fetch_data_from_api(query_str)
+        return Overpass._filter_landmarks(cached_responses, bbox) + non_cached_responses
+
+
+    def fetch_data_from_api(self, query_str: str) -> List[dict]:
+        """
+        Fetch data from the Overpass API and return the json data.
+
+        Args:
+            query_str (str): The Overpass query string.
+
+        Returns:
+            dict: Combined cached and fetched data.
+        """
+        try:
+            data = urllib.parse.urlencode({'data': query_str}).encode('utf-8')
+            request = urllib.request.Request(self.overpass_url, data=data, headers=self.headers)
+
+            with urllib.request.urlopen(request) as response:
+                response_data = response.read().decode('utf-8')  # Convert the HTTPResponse to a string
+                data = json.loads(response_data)  # Load the JSON from the string
+                elements = data.get('elements', [])
+                # self.logger.debug(f'Query = {query_str}')
+                return elements
+
+        except urllib.error.URLError as e:
+            self.logger.error(f"Error connecting to Overpass API: {str(e)}")
+            raise ConnectionError(f"Error connecting to Overpass API: {str(e)}") from e
+        except Exception as exc :
+            self.logger.error(f"unexpected error while fetching data from Overpass: {str(exc)}")
+            raise Exception(f'An unexpected error occured: {str(exc)}') from exc
+
+
+    def fill_cache(self, json_data: dict) :
+        """
+        Fill cache with data by using a hollow cache entry's information.
+        """
+        query_str, cache_key = Overpass._build_query_from_hollow(json_data)
+        try:
+            data = urllib.parse.urlencode({'data': query_str}).encode('utf-8')
+            request = urllib.request.Request(self.overpass_url, data=data, headers=self.headers)
+
+            with urllib.request.urlopen(request) as response:
+
+                # Convert the HTTPResponse to a string and load data
+                response_data = response.read().decode('utf-8')
+                data = json.loads(response_data)
+
+                # Get elements and set cache
+                elements = data.get('elements', [])
+                self.caching_strategy.set(cache_key, elements)
+                self.logger.debug(f'Cache set for {cache_key}')
+        except urllib.error.URLError as e:
+            raise ConnectionError(f"Error connecting to Overpass API: {str(e)}") from e
+        except Exception as exc :
+            raise Exception(f'An unexpected error occured: {str(exc)}') from exc
+
+
+    @staticmethod
+    def build_query(bbox: BBOX, osm_types: OSM_TYPES,
+                    selector: str, conditions: list=None, out='center') -> str:
         """
         Constructs a query string for the Overpass API to retrieve OpenStreetMap (OSM) data.
 
         Args:
-            area (tuple): A tuple representing the geographical search area, typically in the format 
-                        (radius, latitude, longitude). The first element is a string like "around:2000" 
-                        specifying the search radius, and the second and third elements represent 
-                        the latitude and longitude as floats or strings.
+            bbox (tuple): A tuple representing the geographical search area, typically in the format 
+                        (lat_min, lon_min, lat_max, lon_max).
             osm_types (list[str]): A list of OSM element types to search for. Must be one or more of 
                                     'Way', 'Node', or 'Relation'.
             selector (str): The key or tag to filter the OSM elements (e.g., 'amenity', 'highway', etc.).
@@ -52,82 +152,203 @@ class Overpass :
         Notes:
             - If no conditions are provided, the query will just use the `selector` to filter the OSM 
             elements without additional constraints.
-            - The search area must always formatted as "(radius, lat, lon)".
         """
-        if not isinstance(conditions, list) :
-            conditions = [conditions]
-        if not isinstance(osm_types, list) :
-            osm_types = [osm_types]
+        query = '[out:json][timeout:20];('
 
-        query = '('
+        # convert the bbox to string.
+        bbox_str = f"({','.join(map(str, bbox))})"
 
-        # Round the radius to nearest 50 and coordinates to generate less queries
-        if area[0] > 500 :
-            search_radius = round(area[0] / 50) * 50
-            loc = tuple((round(area[1], 2), round(area[2], 2)))
-        else :
-            search_radius = round(area[0] / 25) * 25
-            loc = tuple((round(area[1], 3), round(area[2], 3)))
-
-        search_area = f"(around:{search_radius}, {str(loc[0])}, {str(loc[1])})"
-
-        if conditions :
+        if conditions is not None and len(conditions) > 0:
             conditions = '(if: ' + ' && '.join(conditions) + ')'
         else :
             conditions = ''
 
         for elem in osm_types :
-            query += elem + '[' + selector + ']' + conditions + search_area + ';'
+            query += elem + '[' + selector + ']' + conditions + bbox_str + ';'
 
         query += ');' + f'out {out};'
 
         return query
 
 
-    def send_query(self, query: str) -> ET:
+    def _retrieve_cached_data(self, overlapping_cells: CELL, osm_types: OSM_TYPES,
+                              selector: str, conditions: list, out: str) -> Tuple[List[dict], list[CELL]]:
         """
-        Sends the Overpass QL query to the Overpass API and returns the parsed JSON response.
+        Retrieve cached data and identify missing cache quadrants.
 
         Args:
-            query (str): The Overpass QL query to be sent to the Overpass API.
+            overlapping_cells (list): Cells to check for cached data.
+            osm_types (list): OSM types (e.g., 'node', 'way').
+            selector (str): Key or tag to filter OSM elements.
+            conditions (list): Additional conditions to apply.
+            out (str): Output format.
 
         Returns:
-            dict: The parsed JSON response from the Overpass API, or None if the request fails.
+            tuple: A tuple containing:
+                - cached_responses (list): List of cached data found.
+                - non_cached_cells (list(tuple)): List of cells with missing data.
+        """
+        cell_key_dict = {}
+        for cell in overlapping_cells :
+            for elem in osm_types :
+                key_str = f"{elem}[{selector}]{conditions}({','.join(map(str, cell))})"
+
+            cell_key_dict[cell] = get_cache_key(key_str)
+
+        cached_responses = []
+        non_cached_cells = []
+
+        # Retrieve the cached data and mark the missing entries as hollow
+        for cell, key in cell_key_dict.items():
+            cached_data = self.caching_strategy.get(key)
+            if cached_data is not None :
+                cached_responses += cached_data
+            else:
+                self.caching_strategy.set_hollow(key, cell, osm_types, selector, conditions, out)
+                non_cached_cells.append(cell)
+
+        return cached_responses, non_cached_cells
+
+
+    @staticmethod
+    def _build_query_from_hollow(json_data: dict) -> Tuple[str, str]:
+        """
+        Build query string using information from a hollow cache entry.
+        """
+        # Extract values from the JSON object
+        key = json_data.get('key')
+        cell = tuple(json_data.get('cell'))
+        bbox = Overpass._get_bbox_from_grid_cell(cell)
+        osm_types = json_data.get('osm_types')
+        selector = json_data.get('selector')
+        conditions = json_data.get('conditions')
+        out = json_data.get('out')
+
+
+        query_str = Overpass.build_query(bbox, osm_types, selector, conditions, out)
+        return query_str, key
+
+
+    @staticmethod
+    def _get_overlapping_cells(query_bbox: tuple) -> List[CELL]:
+        """
+        Returns a set of all grid cells that overlap with the given bounding box.
+        """
+        # Extract location from the query bbox
+        lat_min, lon_min, lat_max, lon_max = query_bbox
+
+        min_lat_cell, min_lon_cell = Overpass._get_grid_cell(lat_min, lon_min)
+        max_lat_cell, max_lon_cell = Overpass._get_grid_cell(lat_max, lon_max)
+
+        overlapping_cells = set()
+        for lat_idx in range(min_lat_cell, max_lat_cell + 1):
+            for lon_idx in range(min_lon_cell, max_lon_cell + 1):
+                overlapping_cells.add((lat_idx, lon_idx))
+
+        return overlapping_cells
+
+
+    @staticmethod
+    def _get_grid_cell(lat: float, lon: float) -> CELL:
+        """
+        Returns the grid cell coordinates for a given latitude and longitude.
+        Each grid cell is 0.05°lat x 0.05°lon resolution in size.
+        """
+        lat_index = math.floor(lat / RESOLUTION)
+        lon_index = math.floor(lon / RESOLUTION)
+        return (lat_index, lon_index)
+
+
+    @staticmethod
+    def _get_bbox_from_grid_cell(cell: CELL) -> BBOX:
+        """
+        Returns the bounding box for a given grid cell index.
+        Each grid cell is resolution x resolution in size.
+
+        The bounding box is returned as (min_lat, min_lon, max_lat, max_lon).
+        """
+        # Calculate the southwest (min_lat, min_lon) corner of the bounding box
+        min_lat = round(cell[0] * RESOLUTION, 2)
+        min_lon = round(cell[1] * RESOLUTION, 2)
+
+        # Calculate the northeast (max_lat, max_lon) corner of the bounding box
+        max_lat = round((cell[0] + 1) * RESOLUTION, 2)
+        max_lon = round((cell[1] + 1) * RESOLUTION, 2)
+
+        return (min_lat, min_lon, max_lat, max_lon)
+
+
+    @staticmethod
+    def _get_non_cached_bbox(non_cached_cells: List[CELL], original_bbox: BBOX):
+        """
+        Calculate the non-cached bounding box by excluding cached cells.
+
+        Args:
+            non_cached_cells (list): The list of cells that were not found in the cache.
+            original_bbox (tuple): The original bounding box (min_lat, min_lon, max_lat, max_lon).
+
+        Returns:
+            tuple: The new bounding box that excludes cached cells, or None if all cells are cached.
+        """
+        if not non_cached_cells:
+            return None  # All cells were cached
+
+        # Initialize the non-cached bounding box with extreme values
+        min_lat, min_lon, max_lat, max_lon = float('inf'), float('inf'), float('-inf'), float('-inf')
+
+        # Iterate over non-cached cells to find the new bounding box
+        for cell in non_cached_cells:
+            cell_min_lat, cell_min_lon, cell_max_lat, cell_max_lon = Overpass._get_bbox_from_grid_cell(cell)
+
+            min_lat = min(min_lat, cell_min_lat)
+            min_lon = min(min_lon, cell_min_lon)
+            max_lat = max(max_lat, cell_max_lat)
+            max_lon = max(max_lon, cell_max_lon)
+
+        # If no update to bounding box, return the original
+        if min_lat == float('inf') or min_lon == float('inf'):
+            return None
+
+        return (max(min_lat, original_bbox[0]),
+                max(min_lon, original_bbox[1]),
+                min(max_lat, original_bbox[2]),
+                min(max_lon, original_bbox[3]))
+
+
+    @staticmethod
+    def _filter_landmarks(elements: List[dict], bbox: BBOX) -> List[dict]:
+        """
+        Filters elements based on whether their coordinates are inside the given bbox.
+
+        Args:
+        - elements (list of dict): List of elements containing coordinates.
+        - bbox (tuple): A bounding box defined as (min_lat, min_lon, max_lat, max_lon).
+
+        Returns:
+        - list: A list of elements whose coordinates are inside the bounding box.
         """
 
-        # Generate a cache key for the current query
-        cache_key = get_cache_key(query)
+        filtered_elements = []
+        min_lat, min_lon, max_lat, max_lon = bbox
 
-        # Try to fetch the result from the cache
-        cached_response = self.caching_strategy.get(cache_key)
-        if cached_response is not None :
-            logger.debug("Cache hit.")
-            return cached_response
+        for elem in elements:
+            # Extract coordinates based on the 'type' of element
+            if elem.get('type') != 'node':
+                center = elem.get('center', {})
+                lat = float(center.get('lat', 0))
+                lon = float(center.get('lon', 0))
+            else:
+                lat = float(elem.get('lat', 0))
+                lon = float(elem.get('lon', 0))
 
-        # Prepare the data to be sent as POST request, encoded as bytes
-        data = urllib.parse.urlencode({'data': query}).encode('utf-8')
+            # Check if the coordinates fall within the given bounding box
+            if min_lat <= lat <= max_lat and min_lon <= lon <= max_lon:
+                filtered_elements.append(elem)
 
-        try:
-            # Create a Request object with the specified URL, data, and headers
-            request = urllib.request.Request(self.overpass_url, data=data, headers=self.headers)
-
-            # Send the request and read the response
-            with urllib.request.urlopen(request) as response:
-                # Read and decode the response
-                response_data = response.read().decode('utf-8')
-                root = ET.fromstring(response_data)
-
-                # Cache the response data as an ElementTree root
-                self.caching_strategy.set(cache_key, root)
-                logger.debug("Response data added to cache.")
-
-                return root
-
-        except urllib.error.URLError as e:
-            raise ConnectionError(f"Error connecting to Overpass API: {e}") from e
+        return filtered_elements
 
 
-def get_base_info(elem: ET.Element, osm_type: osm_types, with_name=False) :
+def get_base_info(elem: dict, osm_type: OSM_TYPES, with_name=False) :
     """
     Extracts base information (coordinates, OSM ID, and optionally a name) from an OSM element.
 
@@ -136,7 +357,7 @@ def get_base_info(elem: ET.Element, osm_type: osm_types, with_name=False) :
     extracting coordinates either directly or from a center tag, depending on the element type.
 
     Args:
-        elem (ET.Element): The XML element representing the OSM entity.
+        elem (dict): The JSON element representing the OSM entity.
         osm_type (str): The type of the OSM entity (e.g., 'node', 'way'). If 'node', the coordinates
                         are extracted directly from the element; otherwise, from the 'center' tag.
         with_name (bool): Whether to extract and return the name of the element. If True, it attempts
@@ -150,7 +371,7 @@ def get_base_info(elem: ET.Element, osm_type: osm_types, with_name=False) :
     """
     # 1. extract coordinates
     if osm_type != 'node' :
-        center = elem.find('center')
+        center = elem.get('center')
         lat = float(center.get('lat'))
         lon = float(center.get('lon'))
 
@@ -165,7 +386,40 @@ def get_base_info(elem: ET.Element, osm_type: osm_types, with_name=False) :
 
     # 3. Extract name if specified and return
     if with_name :
-        name = elem.find("tag[@k='name']").get('v') if elem.find("tag[@k='name']") is not None else None
+        name = elem.get('tags', {}).get('name')
         return osm_id, coords, name
-    else :
-        return osm_id, coords
+
+    return osm_id, coords
+
+
+def fill_cache():
+    """
+    Scans the specified cache directory for files starting with 'hollow_' and attempts to load
+    their contents as JSON to fill the cache of the Overpass system.
+    """
+    overpass = Overpass()
+
+    n_files = 0
+    total = 0
+
+    overpass.logger.info('Trip successfully returned, starting to fill cache.')
+
+    with os.scandir(OSM_CACHE_DIR) as it:
+        for entry in it:
+            if entry.is_file() and entry.name.startswith('hollow_'):
+                total += 1
+                try :
+                    # Read the whole file content as a string
+                    with open(entry.path, 'r', encoding='utf-8') as f:
+                        # load data and fill the cache with the query and key
+                        json_data = json.load(f)
+                        overpass.fill_cache(json_data)
+                        n_files += 1
+                        time.sleep(1)
+                    # Now delete the file as the cache is filled
+                    os.remove(entry.path)
+
+                except Exception as exc :
+                    overpass.logger.error(f'An error occured while parsing file {entry.path} as .json file: {str(exc)}')
+
+    overpass.logger.info(f"Successfully filled {n_files}/{total} cache files.")

backend/src/parameters/amenity_selectors.yaml

@@ -72,6 +72,7 @@ sightseeing:
     # - castle
     # - museum
 
+
 museums:
   tourism:
     - museum

backend/src/parameters/landmark_parameters.yaml

@@ -1,12 +1,10 @@
-city_bbox_side: 7500 #m
+max_bbox_side: 4000   #m
 radius_close_to: 50
-church_coeff: 0.55
-nature_coeff: 1.4
+church_coeff: 0.75
+nature_coeff: 1.6
 overall_coeff: 10
 tag_exponent: 1.15
 image_bonus: 1.1
-viewpoint_bonus: 5
+viewpoint_bonus: 10
 wikipedia_bonus: 1.25
-name_bonus: 3
-N_important: 40
 pay_bonus: -1

backend/src/parameters/optimizer_parameters.yaml

@@ -4,3 +4,7 @@ average_walking_speed: 4.8
 max_landmarks: 10
 max_landmarks_refiner: 20
 overshoot: 0.0016
+time_limit: 1
+gap_rel: 0.025
+max_iter: 80
+N_important: 60

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_router.py

@@ -0,0 +1,79 @@
+import logging
+import paypalrestsdk
+from fastapi import HTTPException, APIRouter
+
+from ..supabase.supabase import SupabaseClient
+from .payment_handler import PaymentRequest, PaymentHandler
+
+# Set up logging and supabase
+logger = logging.getLogger(__name__)
+supabase = SupabaseClient()
+
+# 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/structs/landmark.py

@@ -1,5 +1,4 @@
 """Definition of the Landmark class to handle visitable objects across the world."""
-
 from typing import Optional, Literal
 from uuid import uuid4, UUID
 from pydantic import BaseModel, Field
@@ -50,7 +49,8 @@ class Landmark(BaseModel) :
     image_url : Optional[str] = None
     website_url : Optional[str] = None
     wiki_url : Optional[str] = None
-    description : Optional[str] = None                          # TODO future
+    # keywords: Optional[dict] = {}
+    # description : Optional[str] = None
     duration : Optional[int] = 5
     name_en : Optional[str] = None
 
@@ -69,6 +69,7 @@ class Landmark(BaseModel) :
     is_viewpoint : Optional[bool] = False
     is_place_of_worship : Optional[bool] = False
 
+
     def __str__(self) -> str:
         """
         String representation of the Landmark object.
@@ -122,30 +123,3 @@ class Landmark(BaseModel) :
         return (self.uuid == value.uuid or
                 self.osm_id == value.osm_id or
                 (self.name == value.name and self.distance(value) < 0.001))
-
-
-class Toilets(BaseModel) :
-    """
-    Model for toilets. When false/empty the information is either false either not known.
-    """
-    location : tuple
-    wheelchair : Optional[bool] = False
-    changing_table : Optional[bool] = False
-    fee : Optional[bool] = False
-    opening_hours : Optional[str] = ""
-
-
-    def __str__(self) -> str:
-        """
-        String representation of the Toilets object.
-
-        Returns:
-            str: A formatted string with the toilets location.
-        """
-        return f'Toilets @{self.location}'
-
-    class Config:
-        """
-        This allows us to easily convert the model to and from dictionaries
-        """
-        from_attributes = True

backend/src/structs/linked_landmarks.py

@@ -2,6 +2,7 @@
 
 from .landmark import Landmark
 from ..utils.get_time_distance import get_time
+from ..utils.description import description_and_keywords
 
 class LinkedLandmarks:
     """
@@ -35,18 +36,23 @@ class LinkedLandmarks:
         Create the links between the landmarks in the list by setting their 
         .next_uuid and the .time_to_next attributes.
         """
-
         # Mark secondary landmarks as such
         self.update_secondary_landmarks()
 
-
         for i, landmark in enumerate(self._landmarks[:-1]):
+            # Set uuid of the next landmark
             landmark.next_uuid = self._landmarks[i + 1].uuid
+
+            # Adjust time to reach and total time
             time_to_next = get_time(landmark.location, self._landmarks[i + 1].location)
             landmark.time_to_reach_next = time_to_next
             self.total_time += time_to_next
             self.total_time += landmark.duration
 
+            # Fill in the keywords and description. GOOD IDEA, BAD EXECUTION, tags aren't available anymore at this stage
+            # landmark.description, landmark.keywords = description_and_keywords(tags)
+
+
         self._landmarks[-1].next_uuid = None
         self._landmarks[-1].time_to_reach_next = 0
 

backend/src/structs/preferences.py

@@ -1,7 +1,7 @@
 """Defines the Preferences used as input for trip generation."""
 
 from typing import Optional, Literal
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 
 
 class Preference(BaseModel) :
@@ -15,6 +15,13 @@ class Preference(BaseModel) :
     type: Literal['sightseeing', 'nature', 'shopping', 'start', 'finish']
     score: int          # score could be from 1 to 5
 
+    @field_validator("type")
+    @classmethod
+    def validate_type(cls, v):
+        if v not in {'sightseeing', 'nature', 'shopping', 'start', 'finish'}:
+            raise ValueError(f"Invalid type: {v}")
+        return v
+
 
 # Input for optimization
 class Preferences(BaseModel) :
@@ -32,3 +39,16 @@ class Preferences(BaseModel) :
 
     max_time_minute: Optional[int] = 3*60
     detour_tolerance_minute: Optional[int] = 0
+
+
+    def model_post_init(self, __context):
+        """
+        Method to validate proper initialization of individual Preferences.
+        Raises ValueError if the Preference type does not match with the field name.
+        """
+        if self.sightseeing.type != 'sightseeing':
+            raise ValueError(f'The sightseeing preference cannot be {self.sightseeing.type}.')
+        if self.nature.type != 'nature':
+            raise ValueError(f'The nature preference cannot be {self.nature.type}.')
+        if self.shopping.type != 'shopping':
+            raise ValueError(f'The shopping preference cannot be {self.shopping.type}.')

backend/src/structs/toilets.py

@@ -0,0 +1,26 @@
+"""Definition of the Toilets class."""
+from typing import Optional
+from pydantic import BaseModel, ConfigDict
+
+
+class Toilets(BaseModel) :
+    """
+    Model for toilets. When false/empty the information is either false either not known.
+    """
+    location : tuple
+    wheelchair : Optional[bool] = False
+    changing_table : Optional[bool] = False
+    fee : Optional[bool] = False
+    opening_hours : Optional[str] = ""
+
+
+    def __str__(self) -> str:
+        """
+        String representation of the Toilets object.
+
+        Returns:
+            str: A formatted string with the toilets location.
+        """
+        return f'Toilets @{self.location}'
+
+    model_config = ConfigDict(from_attributes=True)

backend/src/supabase/supabase.py

@@ -0,0 +1,169 @@
+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 SupabaseClient:
+
+    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.info('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()
+            )
+
+        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/tests/test_invalid_input.py

@@ -19,30 +19,50 @@ def invalid_client():
         ([48.8566, 2.3522], {}, 422),
 
         # Invalid cases: incomplete preferences.
-        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 5}, # no shopping
+        ([48.084588, 7.280405], {"sightseeing": {"type": "sightseeing", "score": 5},    # no shopping pref
                                  "nature": {"type": "nature", "score": 5},
                                  }, 422),
-        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 5}, # no nature
+        ([48.084588, 7.280405], {"sightseeing": {"type": "sightseeing", "score": 5},    # no nature pref
                                  "shopping": {"type": "shopping", "score": 5},
                                  }, 422),
-        ([48.084588, 7.280405], {"nature": {"type": "nature", "score": 5},      # no sightseeing
+        ([48.084588, 7.280405], {"nature": {"type": "nature", "score": 5},              # no sightseeing pref
                                  "shopping": {"type": "shopping", "score": 5},
                                  }, 422),
+        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 1},         # mixed up preferences types. TODO: i suggest reducing the complexity by remove the Preference object.
+                                 "nature": {"type": "shopping", "score": 1},
+                                 "shopping": {"type": "shopping", "score": 1},
+                                 }, 422),
+        ([48.084588, 7.280405], {"doesnotexist": {"type": "sightseeing", "score": 2},   # non-existing preferences types
+                                 "nature": {"type": "nature", "score": 2},
+                                 "shopping": {"type": "shopping", "score": 2},
+                                 }, 422),
+        ([48.084588, 7.280405], {"sightseeing": {"type": "sightseeing", "score": 3},    # non-existing preferences types
+                                 "nature": {"type": "doesntexisteither", "score": 3},
+                                 "shopping": {"type": "shopping", "score": 3},
+                                 }, 422),
+        ([48.084588, 7.280405], {"sightseeing": {"type": "sightseeing", "score": -1},   # negative preference value
+                                 "nature": {"type": "doesntexisteither", "score": 4},
+                                 "shopping": {"type": "shopping", "score": 4},
+                                 }, 422),
+        ([48.084588, 7.280405], {"sightseeing": {"type": "sightseeing", "score": 10},   # too high preference value
+                                 "nature": {"type": "doesntexisteither", "score": 4},
+                                 "shopping": {"type": "shopping", "score": 4},
+                                 }, 422),
 
         # Invalid cases: unexisting coords
-        ([91, 181], {"sightseeing": {"type": "nature", "score": 5},
+        ([91, 181], {"sightseeing": {"type": "sightseeing", "score": 5},
                      "nature": {"type": "nature", "score": 5},
                      "shopping": {"type": "shopping", "score": 5},
                     }, 422),
-        ([-91, 181], {"sightseeing": {"type": "nature", "score": 5},
+        ([-91, 181], {"sightseeing": {"type": "sightseeing", "score": 5},
                      "nature": {"type": "nature", "score": 5},
                      "shopping": {"type": "shopping", "score": 5},
                     }, 422),
-        ([91, -181], {"sightseeing": {"type": "nature", "score": 5},
+        ([91, -181], {"sightseeing": {"type": "sightseeing", "score": 5},
                      "nature": {"type": "nature", "score": 5},
                      "shopping": {"type": "shopping", "score": 5},
                     }, 422),
-        ([-91, -181], {"sightseeing": {"type": "nature", "score": 5},
+        ([-91, -181], {"sightseeing": {"type": "sightseeing", "score": 5},
                      "nature": {"type": "nature", "score": 5},
                      "shopping": {"type": "shopping", "score": 5},
                     }, 422),
@@ -53,8 +73,8 @@ def test_input(invalid_client, start, preferences, status_code):   # pylint: dis
     Test new trip creation with different sets of preferences and locations.
     """
     response = invalid_client.post(
-        "/trip/new",
-        json={
+        "/get/landmarks",
+        json ={
             "preferences": preferences,
             "start": start
         }

backend/src/tests/test_main.py

@@ -1,344 +0,0 @@
-"""Collection of tests to ensure correct implementation and track progress. """
-import time
-from fastapi.testclient import TestClient
-import pytest
-
-from .test_utils import load_trip_landmarks, log_trip_details
-from ..main import app
-
-@pytest.fixture(scope="module")
-def client():
-    """Client used to call the app."""
-    return TestClient(app)
-
-
-def test_turckheim(client, request):    # pylint: disable=redefined-outer-name
-    """
-    Test n°1 : Custom test in Turckheim to ensure small villages are also supported.
-
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 20
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-            "nature": {"type": "nature", "score": 5},
-            "shopping": {"type": "shopping", "score": 5},
-            "max_time_minute": duration_minutes,
-            "detour_tolerance_minute": 0},
-            "start": [48.084588, 7.280405]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert isinstance(landmarks, list)  # check that the return type is a list
-    assert len(landmarks) > 2           # check that there is something to visit
-    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 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.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 120
-
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [45.7576485, 4.8330241]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    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}"
-
-
-def test_cologne(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°2 : Custom test in Lyon centre to ensure proper decision making in crowded area.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 240
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [50.942352665, 6.957777972392]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    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}"
-
-
-def test_strasbourg(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°2 : Custom test in Lyon centre to ensure proper decision making in crowded area.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 180
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [48.5846589226, 7.74078715721]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    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}"
-
-
-def test_zurich(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°2 : Custom test in Lyon centre to ensure proper decision making in crowded area.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 180
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [47.377884227, 8.5395114066]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    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}"
-
-
-def test_paris(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°2 : Custom test in Paris (les Halles) centre to ensure proper decision making in crowded area.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 300
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [48.86248803298562, 2.346451131285925]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    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}"
-
-
-def test_new_york(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°2 : Custom test in New York (les Halles) centre to ensure proper decision making in crowded area.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 600
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [40.72592726802, -73.9920434795]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # for elem in landmarks :
-    #     print(elem)
-
-    # checks :
-    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}"
-
-
-def test_shopping(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°3 : Custom test in Lyon centre to ensure shopping clusters are found.
-    
-    Args:
-        client:
-        request:
-    """
-    start_time = time.time()  # Start timer
-    duration_minutes = 240
-
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 0},
-                            "nature": {"type": "nature", "score": 0},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [45.7576485, 4.8330241]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Get computation time
-    comp_time = time.time() - start_time
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    for elem in landmarks :
-        print(elem)
-
-    # checks :
-    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}"

backend/src/tests/test_nearby.py

@@ -0,0 +1,46 @@
+"""Collection of tests to ensure correct implementation and track progress of the get_landmarks_nearby feature. """
+
+from fastapi.testclient import TestClient
+import pytest
+
+from ..main import app
+
+
+@pytest.fixture(scope="module")
+def client():
+    """Client used to call the app."""
+    return TestClient(app)
+
+
+@pytest.mark.parametrize(
+    "location,status_code",
+    [
+        ([45.7576485, 4.8330241], 200),    # Lyon, France
+        ([41.4020572, 2.1818985], 200),    # Barcelona, Spain
+        ([59.3293, 18.0686], 200),         # Stockholm, Sweden
+        ([43.6532, -79.3832], 200),        # Toronto, Canada
+        ([38.7223, -9.1393], 200),         # Lisbon, Portugal
+        ([6.5244, 3.3792], 200),           # Lagos, Nigeria
+        ([17.3850, 78.4867], 200),         # Hyderabad, India
+        ([30.0444, 31.2357], 200),         # Cairo, Egypt
+        ([50.8503, 4.3517], 200),          # Brussels, Belgium
+        ([35.2271, -80.8431], 200),        # Charlotte, USA
+        ([10.4806, -66.9036], 200),        # Caracas, Venezuela
+        ([9.51074, -13.71118], 200),       # Conakry, Guinea
+    ]
+)
+def test_nearby(client, location, status_code):    # pylint: disable=redefined-outer-name
+    """
+    Test n°1 : Verify handling of invalid input.
+
+    Args:
+        client:
+        request:
+    """
+    response = client.post(f"/get-nearby/landmarks/{location[0]}/{location[1]}")
+    suggestions = response.json()
+
+    # checks :
+    assert response.status_code == status_code  # check for successful planning
+    assert isinstance(suggestions, list)  # check that the return type is a list
+    assert len(suggestions) > 0

backend/src/tests/test_toilets.py

@@ -3,7 +3,7 @@
 from fastapi.testclient import TestClient
 import pytest
 
-from ..structs.landmark import Toilets
+from ..structs.toilets import Toilets
 from ..main import app
 
 
@@ -18,7 +18,7 @@ def client():
     [
         ({}, None, 422),                # Invalid case: no location at all.
         ([443], None, 422),             # Invalid cases: invalid location.
-        ([443, 433], None, 422),             # Invalid cases: invalid location.
+        ([443, 433], None, 422),        # Invalid cases: invalid location.
     ]
 )
 def test_invalid_input(client, location, radius, status_code):    # pylint: disable=redefined-outer-name
@@ -30,7 +30,7 @@ def test_invalid_input(client, location, radius, status_code):    # pylint: disa
         request:
     """
     response = client.post(
-        "/toilets/new",
+        "/get/toilets",
         params={
             "location": location,
             "radius": radius
@@ -58,7 +58,7 @@ def test_no_toilets(client, location, status_code):    # pylint: disable=redefin
         request:
     """
     response = client.post(
-        "/toilets/new",
+        "/get/toilets",
         params={
             "location": location
         }
@@ -87,7 +87,7 @@ def test_toilets(client, location, status_code):    # pylint: disable=redefined-
         request:
     """
     response = client.post(
-        "/toilets/new",
+        "/get/toilets",
         params={
             "location": location,
             "radius" : 600

backend/src/tests/test_trip_generation.py

@@ -0,0 +1,101 @@
+"""Collection of tests to ensure correct implementation and track progress."""
+import os
+import time
+import yaml
+from fastapi.testclient import TestClient
+import pytest
+
+from .test_utils import load_trip_landmarks, log_trip_details
+from ..supabase.supabase import SupabaseClient
+from ..structs.preferences import Preferences, Preference
+from ..constants import PARAMETERS_DIR
+from ..main import app
+
+
+# Create a supabase client
+supabase = SupabaseClient()
+
+
+@pytest.fixture(scope="module")
+def client():
+    """Client used to call the app."""
+    return TestClient(app)
+
+
+@pytest.mark.parametrize(
+    "sightseeing, shopping, nature, max_time_minute, start_coords, end_coords",
+    [
+        # Edge cases
+        (0, 0, 5, 240, [45.7576485, 4.8330241], None),                  # Lyon, Bellecour - test shopping only
+        
+        # Realistic
+        (5, 0, 0, 20, [48.0845881, 7.2804050], None),                   # Turckheim
+        (5, 5, 5, 120, [45.7576485, 4.8330241], None),                  # Lyon, Bellecour
+        (5, 2, 5, 240, [50.9423526, 6.9577780], None),                  # Cologne, centre
+        (3, 5, 0, 180, [48.5846589226, 7.74078715721], None),           # Strasbourg, centre
+        (2, 4, 5, 180, [47.377884227, 8.5395114066], None),             # Zurich, centre
+        (5, 0, 5, 200, [48.85468881798671, 2.3423925755998374], None),  # Paris, centre
+        (5, 5, 5, 600, [40.72592726802, -73.9920434795], None),         # New York, Lower Manhattan
+    ]
+)
+def test_trip(client, request, sightseeing, shopping, nature, max_time_minute, start_coords, end_coords):
+
+    start_time = time.time()  # Start timer
+
+    prefs = Preferences(
+        sightseeing=Preference(type='sightseeing', score=sightseeing),
+        shopping=Preference(type='shopping', score=shopping),
+        nature=Preference(type='nature', score=nature),
+        max_time_minute=max_time_minute,
+        detour_tolerance_minute=0,
+    )
+    start = start_coords
+    end = end_coords
+
+    # Step 1: request the list of landmarks in the vicinty of the starting point
+    response = client.post(
+        "/get/landmarks",
+        json={
+            "preferences": prefs.model_dump(),
+            "start": start_coords,
+            "end": end_coords,
+            }
+        )
+
+    assert response.status_code == 200
+    landmarks = response.json()
+
+    # Step 2: Feed the landmarks to the optimizer to compute the trip
+    response = client.post(
+        "/optimize/trip",
+        json={
+            "user_id": supabase.SUPABASE_TEST_USER_ID,
+            "preferences": prefs.model_dump(),
+            "landmarks": landmarks,
+            "start": start,
+            "end": end,
+            }
+        )
+    assert response.status_code == 200
+    
+    # Increment the user balance again
+    supabase.increment_credit_balance(
+        supabase.SUPABASE_TEST_USER_ID,
+        amount=1
+    )
+
+    # Parse the response
+    result = response.json()
+    # print(result)
+    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
+
+    # Get computation time
+    comp_time = time.time() - start_time
+
+    # Add details to report
+    log_trip_details(request, landmarks, result['total_time'], prefs.max_time_minute)
+
+    # checks :
+    assert comp_time < 30, f"Computation time exceeded 30 seconds: {comp_time:.2f} seconds"
+    assert prefs.max_time_minute*0.8 < result['total_time'], f"Trip too short: {result['total_time']} instead of {prefs.max_time_minute}"
+    assert prefs.max_time_minute*1.2 > result['total_time'], f"Trip too long: {result['total_time']} instead of {prefs.max_time_minute}"

backend/src/tests/test_utils.py

@@ -1,10 +1,12 @@
 """Helper methods for testing."""
+import time
 import logging
+from functools import wraps
 from fastapi import HTTPException
-from pydantic import ValidationError
 
-from ..structs.landmark import Landmark
 from ..cache import client as cache_client
+from ..structs.landmark import Landmark
+from ..structs.preferences import Preferences, Preference
 
 
 def landmarks_to_osmid(landmarks: list[Landmark]) -> list[int] :
@@ -39,7 +41,7 @@ def fetch_landmark(landmark_uuid: str):
     try:
         landmark = cache_client.get(f'landmark_{landmark_uuid}')
         if not landmark :
-            logger.warning(f'Cache miss for landmark UUID: {landmark_uuid}')
+            logger.error(f'Cache miss for landmark UUID: {landmark_uuid}')
             raise HTTPException(status_code=404, detail=f'Landmark with UUID {landmark_uuid} not found in cache.')
 
         # Validate that the fetched data is a dictionary
@@ -92,3 +94,34 @@ def log_trip_details(request, landmarks: list[Landmark], duration: int, target_d
     request.node.trip_details = trip_string
     request.node.trip_duration = str(duration)              # result['total_time']
     request.node.target_duration = str(target_duration)
+
+
+
+
+def trip_params(
+    sightseeing: int,
+    shopping: int,
+    nature: int,
+    max_time_minute: int,
+    start_coords: tuple[float, float] = None,
+    end_coords: tuple[float, float] = None,
+):
+    def decorator(test_func):
+        @wraps(test_func)
+        def wrapper(client, request):
+            prefs = Preferences(
+                sightseeing=Preference(type='sightseeing', score=sightseeing),
+                shopping=Preference(type='shopping', score=shopping),
+                nature=Preference(type='nature', score=nature),
+                max_time_minute=max_time_minute,
+                detour_tolerance_minute=0,
+            )
+
+            start = start_coords
+            end = end_coords
+
+            # Inject into test function
+            return test_func(client, request, prefs, start, end)
+
+        return wrapper
+    return decorator

backend/src/toilets/toilets_manager.py

@@ -1,10 +1,9 @@
 """Module for finding public toilets around given coordinates."""
 import logging
-import xml.etree.ElementTree as ET
 
 from ..overpass.overpass import Overpass, get_base_info
-from ..structs.landmark import Toilets
-from ..constants import OSM_CACHE_DIR
+from ..structs.toilets import Toilets
+from ..utils.bbox import create_bbox
 
 
 # silence the overpass logger
@@ -41,7 +40,7 @@ class ToiletsManager:
         self.location = location
 
         # Setup the caching in the Overpass class.
-        self.overpass = Overpass(caching_strategy='XML', cache_dir=OSM_CACHE_DIR)
+        self.overpass = Overpass()
 
 
     def generate_toilet_list(self) -> list[Toilets] :
@@ -53,73 +52,73 @@ class ToiletsManager:
         list[Toilets]: A list of `Toilets` objects containing detailed information 
                        about the toilets found around the given coordinates.
         """
-        bbox = tuple((self.radius, self.location[0], self.location[1]))
+        bbox = create_bbox(self.location, self.radius)
         osm_types = ['node', 'way', 'relation']
         toilets_list = []
 
-        query = self.overpass.build_query(
-                area = bbox,
-                osm_types = osm_types,
-                selector = '"amenity"="toilets"',
-                out = 'ids center tags'
-                )
-        self.logger.debug(f"Query: {query}")
-
+        query = Overpass.build_query(
+            bbox = bbox,
+            osm_types = osm_types,
+            selector = '"amenity"="toilets"',
+            out = 'ids center tags'
+            )
         try:
-            result = self.overpass.send_query(query)
+            result = self.overpass.fetch_data_from_api(query_str=query)
         except Exception as e:
-            self.logger.error(f"Error fetching landmarks: {e}")
+            self.logger.error(f"Error fetching toilets: {e}")
             return None
 
-        toilets_list = self.xml_to_toilets(result)
+        toilets_list = self.to_toilets(result)
+
+        self.logger.debug(f'Found {len(toilets_list)} toilets around {self.location}')
 
         return toilets_list
 
 
-    def xml_to_toilets(self, root: ET.Element) -> list[Toilets]:
+    def to_toilets(self, elements: list) -> list[Toilets]:
         """
         Parse the Overpass API result and extract landmarks.
 
-        This method processes the XML root element returned by the Overpass API and 
+        This method processes the JSON elements returned by the Overpass API and 
         extracts landmarks of types 'node', 'way', and 'relation'. It retrieves 
         relevant information such as name, coordinates, and tags, and converts them 
         into Landmark objects.
 
         Args:
-        root (ET.Element): The root element of the XML response from Overpass API.
+        list (osm elements): The root element of the JSON response from Overpass API.
         elem_type (str): The type of landmark (e.g., node, way, relation).
 
         Returns:
-        list[Landmark]: A list of Landmark objects extracted from the XML data.
+        list[Landmark]: A list of Landmark objects extracted from the JSON data.
         """
-        if root is None :
+        if elements is None :
             return []
 
         toilets_list = []
-        for osm_type in ['node', 'way', 'relation'] :
-            for elem in root.findall(osm_type):
-                # Get coordinates and append them to the points list
-                _, coords = get_base_info(elem, osm_type)
-                if coords is None :
-                    continue
+        for elem in elements:
+            osm_type = elem.get('type')
+            # Get coordinates and append them to the points list
+            _, coords = get_base_info(elem, osm_type)
+            if coords is None :
+                continue
 
-                toilets = Toilets(location=coords)
+            toilets = Toilets(location=coords)
 
-                # Extract tags as a dictionary
-                tags = {tag.get('k'): tag.get('v') for tag in elem.findall('tag')}
+            # Extract tags as a dictionary
+            tags = elem.get('tags')
 
-                if 'wheelchair' in tags.keys() and tags['wheelchair'] == 'yes':
-                    toilets.wheelchair = True
+            if 'wheelchair' in tags.keys() and tags['wheelchair'] == 'yes':
+                toilets.wheelchair = True
 
-                if 'changing_table' in tags.keys() and tags['changing_table'] == 'yes':
-                    toilets.changing_table = True
+            if 'changing_table' in tags.keys() and tags['changing_table'] == 'yes':
+                toilets.changing_table = True
 
-                if 'fee' in tags.keys() and tags['fee'] == 'yes':
-                    toilets.fee = True
+            if 'fee' in tags.keys() and tags['fee'] == 'yes':
+                toilets.fee = True
 
-                if 'opening_hours' in tags.keys() :
-                    toilets.opening_hours = tags['opening_hours']
+            if 'opening_hours' in tags.keys() :
+                toilets.opening_hours = tags['opening_hours']
 
-                toilets_list.append(toilets)
+            toilets_list.append(toilets)
 
         return toilets_list

backend/src/toilets/toilets_router.py

@@ -0,0 +1,43 @@
+"""API entry point for fetching toilet locations."""
+
+from fastapi import HTTPException, APIRouter, Query
+
+from .toilets_manager import ToiletsManager
+from ..structs.toilets import Toilets
+
+
+# Initialize the API router
+router = APIRouter()
+
+
+@router.post("/get/toilets")
+def get_toilets(
+        location: tuple[float, float] = Query(...),
+        radius: int = 500
+    ) -> list[Toilets] :
+    """
+    Endpoint to find toilets within a specified radius from a given location.
+
+    This endpoint expects the `location` and `radius` as **query parameters**, not in the request body.
+
+    Args:
+        location (tuple[float, float]): The latitude and longitude of the location to search from.
+        radius (int, optional): The radius (in meters) within which to search for toilets. Defaults to 500 meters.
+
+    Returns:
+        list[Toilets]: A list of Toilets objects that meet the criteria.
+    """
+    if location is None:
+        raise HTTPException(status_code=406, detail="Coordinates not provided or invalid")
+    if not (-90 <= location[0] <= 90 or -180 <= location[1] <= 180):
+        raise HTTPException(status_code=422, detail="Start coordinates not in range")
+
+    toilets_manager = ToiletsManager(location, radius)
+
+    try :
+        toilets_list = toilets_manager.generate_toilet_list()
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="No toilets found") from exc
+    
+
+    return toilets_list

backend/src/utils/bbox.py

@@ -0,0 +1,27 @@
+"""Various helper functions"""
+import math as m
+
+def create_bbox(coords: tuple[float, float], radius: int):
+    """
+    Create a bounding box around the given coordinates.
+
+    Args:
+        coords (tuple[float, float]): The latitude and longitude of the center of the bounding box.
+        radius (int): The half-side length of the bounding box in meters.
+
+    Returns:
+        tuple[float, float, float, float]: The minimum latitude, minimum longitude, maximum latitude, and maximum longitude
+                                            defining the bounding box.
+    """
+    # Earth's radius in meters
+    R = 6378137
+    lat, lon = coords
+    d_lat = radius / R
+    d_lon = radius / (R * m.cos(m.pi * lat / 180))
+
+    lat_min = lat - d_lat * 180 / m.pi
+    lat_max = lat + d_lat * 180 / m.pi
+    lon_min = lon - d_lon * 180 / m.pi
+    lon_max = lon + d_lon * 180 / m.pi
+
+    return (lat_min, lon_min, lat_max, lon_max)

backend/src/utils/description.py

@@ -0,0 +1,123 @@
+"""Add more information about the landmarks by writing a short description and keywords. """
+
+
+def description_and_keywords(tags: dict):
+    """
+    Generates a description and a set of keywords for a given landmark based on its tags.
+
+    Params:
+        tags (dict): A dictionary containing metadata about the landmark, including its name,
+                importance, height, date of construction, and visitor information.
+
+    Returns:
+        description (str): A string description of the landmark.
+        keywords (dict): A dictionary of keywords with fields such as 'importance', 'height',
+                    'place_type', and 'date'.
+    """
+    # Extract relevant fields
+    name = tags.get('name')
+    importance = tags.get('importance', None)
+    n_visitors = tags.get('tourism:visitors', None)
+    height = tags.get('height')
+    place_type = get_place_type(tags)
+    date = get_date(tags)
+
+    if place_type is None :
+        return None, None
+
+    # Start the description.
+    if importance is None :
+        if len(tags.keys()) < 5 :
+            return None, None
+        if len(tags.keys()) < 10 :
+            description = f"{name} is a well known {place_type}."
+        elif len(tags.keys()) < 17 :
+            importance = 'national'
+            description = f"{name} is a {place_type} of national importance."
+        else :
+            importance = 'international'
+            description = f"{name} is an internationally famous {place_type}."
+    else :
+        description = f"{name} is a {place_type} of {importance} importance."
+
+    if height is not None and date is not None :
+        description += f" This {place_type} was constructed in {date} and is ca. {height} meters high."
+    elif height is not None :
+        description += f" This {place_type} stands ca. {height} meters tall."
+    elif date is not None:
+        description += f" It was constructed in {date}."
+
+    # Format the visitor number
+    if n_visitors is not None :
+        n_visitors = int(n_visitors)
+        if n_visitors < 1000000 :
+            description += f" It welcomes {int(n_visitors/1000)} thousand visitors every year."
+        else :
+            description += f" It welcomes {round(n_visitors/1000000, 1)} million visitors every year."
+
+    # Set the keywords.
+    keywords = {"importance": importance,
+                "height": height,
+                "place_type": place_type,
+                "date": date}
+
+    return description, keywords
+
+
+def get_place_type(tags):
+    """
+    Determines the type of the place based on available tags such as 'amenity', 'building',
+    'historic', and 'leisure'. The priority order is: 'historic' > 'building' (if not generic) > 
+    'amenity' > 'leisure'.
+
+    Params:
+        tags (dict): A dictionary containing metadata about the place.
+
+    Returns:
+        place_type (str): The determined type of the place, or None if no relevant type is found.
+    """
+    amenity = tags.get('amenity', None)
+    building = tags.get('building', None)
+    historic = tags.get('historic', None)
+    leisure = tags.get('leisure')
+
+    if historic and historic != "yes":
+        return historic
+    if building and building not in ["yes", "civic", "government", "apartments", "residential", "commericial", "industrial", "retail", "religious", "public", "service"]:
+        return building
+    if amenity:
+        return amenity
+    if leisure:
+        return leisure
+
+
+    return None
+
+
+def get_date(tags):
+    """
+    Extracts the most relevant date from the available tags, prioritizing 'construction_date',
+    'start_date', 'year_of_construction', and 'opening_date' in that order.
+
+    Params:
+        tags (dict): A dictionary containing metadata about the place.
+
+    Returns:
+        date (str): The most relevant date found, or None if no date is available.
+    """
+    construction_date = tags.get('construction_date', None)
+    opening_date = tags.get('opening_date', None)
+    start_date = tags.get('start_date', None)
+    year_of_construction = tags.get('year_of_construction', None)
+
+    # Prioritize based on availability
+    if construction_date:
+        return construction_date
+    if start_date:
+        return start_date
+    if year_of_construction:
+        return year_of_construction
+    if opening_date:
+        return opening_date
+
+    return None

backend/src/utils/take_most_important.py

@@ -1,17 +0,0 @@
-"""Helper function to return only the major landmarks from a large list."""
-from ..structs.landmark import Landmark
-
-def take_most_important(landmarks: list[Landmark], n_important) -> list[Landmark]:
-    """
-    Given a list of landmarks, return the n_important most important landmarks
-    Args:
-    landmarks: list[Landmark] - list of landmarks
-    n_important: int - number of most important landmarks to return
-    Returns:
-    list[Landmark] - list of the n_important most important landmarks
-    """
-
-    # Sort landmarks by attractiveness (descending)
-    sorted_landmarks = sorted(landmarks, key=lambda x: x.attractiveness, reverse=True)
-
-    return sorted_landmarks[:n_important]

frontend/lib/main.dart

@@ -1,10 +1,12 @@
+import 'package:anyway/utils/get_first_page.dart';
+import 'package:anyway/utils/load_trips.dart';
 import 'package:flutter/material.dart';
 import 'package:anyway/constants.dart';
-import 'package:anyway/layout.dart';
 
 void main() => runApp(const App());
 
 final GlobalKey<ScaffoldMessengerState> rootScaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
+final SavedTrips savedTrips = SavedTrips();
 
 class App extends StatelessWidget {
   const App({super.key});
@@ -14,7 +16,7 @@ class App extends StatelessWidget {
   Widget build(BuildContext context) {
     return MaterialApp(
       title: APP_NAME,
-      home: BasePage(mainScreen: "map"),
+      home: getFirstPage(),
       theme: APP_THEME,
       scaffoldMessengerKey: rootScaffoldMessengerKey
     );

frontend/lib/modules/current_trip_landmarks_list.dart

@@ -5,7 +5,6 @@ import 'package:flutter/material.dart';
 import 'package:anyway/modules/landmark_card.dart';
 import 'package:anyway/structs/landmark.dart';
 import 'package:anyway/structs/trip.dart';
-import 'package:anyway/main.dart';
 
 
 
@@ -25,30 +24,7 @@ List<Widget> landmarksList(Trip trip) {
 
   for (Landmark landmark in trip.landmarks) {
     children.add(
-      Dismissible(
-        key: ValueKey<int>(landmark.hashCode),
-        child: LandmarkCard(landmark),
-        dismissThresholds: {DismissDirection.endToStart: 0.95, DismissDirection.startToEnd: 0.95},
-        onDismissed: (direction) {
-          log('Removing ${landmark.name}');
-          trip.removeLandmark(landmark);
-
-          rootScaffoldMessengerKey.currentState!.showSnackBar(
-            SnackBar(content: Text("We won't show ${landmark.name} again"))
-          );
-        },
-
-        background: Container(color: Colors.red),
-        secondaryBackground: Container(
-          color: Colors.red,
-          child: Icon(
-            Icons.delete,
-            color: Colors.white,
-          ),
-          padding: EdgeInsets.all(15),
-          alignment: Alignment.centerRight,
-        ),
-      )
+      LandmarkCard(landmark, trip),
     );
 
     if (landmark.next != null) {

frontend/lib/modules/current_trip_loading_indicator.dart

@@ -1,9 +1,20 @@
+import 'package:anyway/constants.dart';
 import 'package:flutter/material.dart';
 import 'package:auto_size_text/auto_size_text.dart';
 
 import 'package:anyway/structs/trip.dart';
 import 'package:anyway/pages/current_trip.dart';
 
+
+final List<String> statusTexts = [
+  'Parsing your preferences...',
+  'Finding the best places...',
+  'Crunching the numbers...',
+  'Calculating the best route...',
+  'Making sure you have a great time...',
+];
+
+
 class CurrentTripLoadingIndicator extends StatefulWidget {
   final Trip trip;
   const CurrentTripLoadingIndicator({
@@ -15,46 +26,137 @@ class CurrentTripLoadingIndicator extends StatefulWidget {
   State<CurrentTripLoadingIndicator> createState() => _CurrentTripLoadingIndicatorState();
 }
 
+
 class _CurrentTripLoadingIndicatorState extends State<CurrentTripLoadingIndicator> {
   @override
-  Widget build(BuildContext context) => Center(
-    child: FutureBuilder(
-      future: widget.trip.cityName,
-      builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
-        Widget greeter;
-        Widget loadingIndicator = const Padding(
-          padding: EdgeInsets.only(top: 10),
-          child: CircularProgressIndicator()
-        );
-
-        if (snapshot.hasData) {
-          greeter = AutoSizeText(
-            maxLines: 1,
-            'Generating your trip to ${snapshot.data}...',
-            style: greeterStyle,
-          );
-        } else if (snapshot.hasError) {
-          // the exact error is shown in the central part of the trip overview. No need to show it here
-          greeter = AutoSizeText(
-            maxLines: 1,
-            'Error while loading trip.',
-            style: greeterStyle,
-            );
-        } else {
-          greeter = AutoSizeText(
-            maxLines: 1,
-            'Generating your trip...',
-            style: greeterStyle,
-            );
-        }
-        return Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            greeter,
-            loadingIndicator,
-          ],
-        );
-      }
-    )
+  Widget build(BuildContext context) => Stack(
+    fit: StackFit.expand,
+    children: [
+      // In the very center of the panel, show the greeter which tells the user that the trip is being generated
+      Center(child: loadingText(widget.trip)),
+      // As a gimmick, and a way to show that the app is still working, show a few loading dots
+      Align(
+        alignment: Alignment.bottomCenter,
+        child: statusText(),
+      )
+    ],
   );
-}
+}
+
+// automatically cycle through the greeter texts
+class statusText extends StatefulWidget {
+  const statusText({Key? key}) : super(key: key);
+
+  @override
+  _statusTextState createState() => _statusTextState();
+}
+
+class _statusTextState extends State<statusText> {
+  int statusIndex = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    Future.delayed(Duration(seconds: 5), () {
+      setState(() {
+        statusIndex = (statusIndex + 1) % statusTexts.length;
+      });
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AutoSizeText(
+      statusTexts[statusIndex],
+      style: Theme.of(context).textTheme.labelSmall,
+    );
+  }
+}
+
+
+
+Widget loadingText(Trip trip) => FutureBuilder(
+  future: trip.cityName,
+  builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
+    Widget greeter;
+
+    if (snapshot.hasData) {
+      greeter = AnimatedGradientText(
+        text: 'Creating your trip to ${snapshot.data}...',
+        style: greeterStyle,
+      );
+    } else if (snapshot.hasError) {
+      // the exact error is shown in the central part of the trip overview. No need to show it here
+      greeter = AnimatedGradientText(
+        text: 'Error while loading trip.',
+        style: greeterStyle,
+      );
+    } else {
+      greeter = AnimatedGradientText(
+        text: 'Creating your trip...',
+        style: greeterStyle,
+      );
+    }
+    return greeter;
+  }
+);
+
+class AnimatedGradientText extends StatefulWidget {
+  final String text;
+  final TextStyle style;
+
+  const AnimatedGradientText({
+    Key? key,
+    required this.text,
+    required this.style,
+  }) : super(key: key);
+
+  @override
+  _AnimatedGradientTextState createState() => _AnimatedGradientTextState();
+}
+
+class _AnimatedGradientTextState extends State<AnimatedGradientText> with SingleTickerProviderStateMixin {
+  late AnimationController _controller;
+
+  @override
+  void initState() {
+    super.initState();
+    _controller = AnimationController(
+      duration: const Duration(seconds: 1),
+      vsync: this,
+    )..repeat();
+  }
+
+  @override
+  void dispose() {
+    _controller.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AnimatedBuilder(
+      animation: _controller,
+      builder: (context, child) {
+        return ShaderMask(
+          shaderCallback: (bounds) {
+            return LinearGradient(
+              colors: [GRADIENT_START, GRADIENT_END, GRADIENT_START],
+              stops: [
+                _controller.value - 1.0,
+                _controller.value,
+                _controller.value + 1.0,
+              ],
+              tileMode: TileMode.mirror,
+            ).createShader(bounds);
+          },
+          child: Text(
+            widget.text,
+            style: widget.style,
+          ),
+        );
+      },
+    );
+  }
+}
+

frontend/lib/modules/current_trip_panel.dart

@@ -36,7 +36,7 @@ class _CurrentTripPanelState extends State<CurrentTripPanel> {
               child: SizedBox(
                 // reuse the exact same height as the panel has when collapsed
                 // this way the greeter will be centered when the panel is collapsed
-                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 20,
+                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT,
                 child: CurrentTripErrorMessage(trip: widget.trip)
               ),
             );
@@ -46,19 +46,20 @@ class _CurrentTripPanelState extends State<CurrentTripPanel> {
               child: SizedBox(
                 // reuse the exact same height as the panel has when collapsed
                 // this way the greeter will be centered when the panel is collapsed
-                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 20,
+                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT,
                 child: CurrentTripLoadingIndicator(trip: widget.trip),
               ),
             );
         } else {
           return ListView(
             controller: widget.controller,
-            padding: const EdgeInsets.only(bottom: 30),
+            padding: const EdgeInsets.only(top: 10, left: 10, right: 10, bottom: 30),
             children: [
               SizedBox(
                 // reuse the exact same height as the panel has when collapsed
                 // this way the greeter will be centered when the panel is collapsed
-                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 20,
+                // note that we need to account for the padding above
+                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 10,
                 child: CurrentTripGreeter(trip: widget.trip),
               ),
 
@@ -72,7 +73,7 @@ class _CurrentTripPanelState extends State<CurrentTripPanel> {
 
               const Padding(padding: EdgeInsets.only(top: 10)),
 
-              Center(child: saveButton(widget.trip)),
+              Center(child: saveButton(trip: widget.trip)),
             ],
           );
         }

frontend/lib/modules/current_trip_save_button.dart

@@ -3,39 +3,53 @@ import 'package:anyway/main.dart';
 import 'package:anyway/structs/trip.dart';
 import 'package:auto_size_text/auto_size_text.dart';
 import 'package:flutter/material.dart';
-import 'package:shared_preferences/shared_preferences.dart';
 
-Widget saveButton(Trip trip) => ElevatedButton(
-  onPressed: () async {
-    SharedPreferences prefs = await SharedPreferences.getInstance();
-    trip.toPrefs(prefs);
-    rootScaffoldMessengerKey.currentState!.showSnackBar(
-      SnackBar(
-        content: Text('Trip saved'),
-        duration: Duration(seconds: 2),
-        dismissDirection: DismissDirection.horizontal
+
+class saveButton extends StatefulWidget {
+  Trip trip;
+  saveButton({super.key, required this.trip});
+
+  @override
+  State<saveButton> createState() => _saveButtonState();
+}
+
+class _saveButtonState extends State<saveButton> {
+  @override
+  Widget build(BuildContext context) {
+    return ElevatedButton(
+      onPressed: () async {
+        savedTrips.addTrip(widget.trip);
+        // SharedPreferences prefs = await SharedPreferences.getInstance();
+        // setState(() => widget.trip.toPrefs(prefs));
+        rootScaffoldMessengerKey.currentState!.showSnackBar(
+          SnackBar(
+            content: Text('Trip saved'),
+            duration: Duration(seconds: 2),
+            dismissDirection: DismissDirection.horizontal
+          )
+        );
+      },
+      child: SizedBox(
+        width: 100,
+        child: Row(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Icon(
+              Icons.save,
+            ),
+            Expanded(
+              child: Padding(
+                padding: EdgeInsets.only(left: 10, top: 5, bottom: 5, right: 5),
+                child: AutoSizeText(
+                  'Save trip',
+                  maxLines: 2,
+                ),
+              ),
+            ),
+          ],
+        ),
       )
     );
-  },
-  child: SizedBox(
-    width: 100,
-    child: Row(
-      mainAxisAlignment: MainAxisAlignment.center,
-      children: [
-        Icon(
-          Icons.save,
-        ),
-        Expanded(
-          child: Padding(
-            padding: EdgeInsets.only(left: 10, top: 5, bottom: 5, right: 5),
-            child: AutoSizeText(
-              'Save trip',
-              maxLines: 2,
-            ),
-          ),
-        ),
-      ],
-    ),
-  )
-);
+  }
+}
 

frontend/lib/modules/help_dialog.dart

@@ -0,0 +1,25 @@
+
+import 'package:flutter/material.dart';
+
+Future<void> helpDialog(BuildContext context, String title, String content) {
+  return showDialog<void>(
+    context: context,
+    builder: (BuildContext context) {
+      return AlertDialog(
+        title: Text(title),
+        content: Text(content),
+        actions: <Widget>[
+          TextButton(
+            style: TextButton.styleFrom(
+              textStyle: Theme.of(context).textTheme.labelLarge,
+            ),
+            child: const Text('Got it!'),
+            onPressed: () {
+              Navigator.of(context).pop();
+            },
+          ),
+        ],
+      );
+    },
+  );
+}

frontend/lib/modules/landmark_card.dart

@@ -1,3 +1,5 @@
+import 'package:anyway/main.dart';
+import 'package:anyway/structs/trip.dart';
 import 'package:flutter/material.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import 'package:url_launcher/url_launcher.dart';
@@ -6,8 +8,12 @@ import 'package:anyway/structs/landmark.dart';
 
 class LandmarkCard extends StatefulWidget {
   final Landmark landmark;
+  final Trip parentTrip;
   
-  LandmarkCard(this.landmark);
+  LandmarkCard(
+    this.landmark,
+    this.parentTrip,
+    );
   
   @override
   _LandmarkCardState createState() => _LandmarkCardState();
@@ -17,110 +23,149 @@ class LandmarkCard extends StatefulWidget {
 class _LandmarkCardState extends State<LandmarkCard> {
   @override
   Widget build(BuildContext context) {
-    ThemeData theme = Theme.of(context);
+    if (widget.landmark.type == typeStart || widget.landmark.type == typeFinish) {
+      return TextButton.icon(
+        onPressed: () {},
+        icon: widget.landmark.type.icon,
+        label: Text(widget.landmark.name),
+      );
+
+    }
+    // else:
     return Container(
-      height: 160,
       child: Card(
         shape: RoundedRectangleBorder(
           borderRadius: BorderRadius.circular(15.0),
         ),
         elevation: 5,
         clipBehavior: Clip.antiAliasWithSaveLayer,
-        child: Row(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            Container( // the image on the left
-              // inherit the height of the parent container
-              height: double.infinity,
-              // force a fixed width
-              width: 160,
-              child: CachedNetworkImage(
-                imageUrl: widget.landmark.imageURL ?? '',
-                placeholder: (context, url) => Center(child: CircularProgressIndicator()),
-                errorWidget: (context, error, stackTrace) => Icon(Icons.question_mark_outlined),
-                // TODO: make this a switch statement to load a placeholder if null
-                // cover the whole container meaning the image will be cropped
-                fit: BoxFit.cover,
-              ),
-            ),
-            Flexible(
-              child: Padding(
-                padding: EdgeInsets.all(10),
-                child: Column(
-                  children: [
-                    Row(
-                      children: [
-                        Flexible(
-                          child: Text(
-                            widget.landmark.name,
-                            style: const TextStyle(
-                              fontSize: 18,
-                              fontWeight: FontWeight.bold,
-                            ),
-                            maxLines: 2,
-                          ),
-                        )
-                      ],
-                    ),
-                    if (widget.landmark.nameEN != null)
-                      Row(
-                        children: [
-                          Flexible(
-                            child: Text(
-                              widget.landmark.nameEN!,
-                              style: const TextStyle(
-                                fontSize: 16,
-                              ),
-                              maxLines: 1,
-                            ),
-                          )
-                        ],
-                      ),
-                    SingleChildScrollView(
-                      // allows the buttons to be scrolled
-                      scrollDirection: Axis.horizontal,
-                      child: Wrap(
-                        spacing: 10,
-                        // show the type, the website, and the wikipedia link as buttons/labels in a row
-                        children: [
-                          TextButton.icon(
-                            onPressed: () {},
-                            icon: widget.landmark.type.icon,
-                            label: Text(widget.landmark.type.name),
-                          ),
-                          if (widget.landmark.duration != null && widget.landmark.duration!.inMinutes > 0)
-                            TextButton.icon(
-                              onPressed: () {},
-                              icon: Icon(Icons.hourglass_bottom),
-                              label: Text('${widget.landmark.duration!.inMinutes} minutes'),
-                            ),
-                          if (widget.landmark.websiteURL != null)
-                            TextButton.icon(
-                              onPressed: () async {
-                                // open a browser with the website link
-                                await launchUrl(Uri.parse(widget.landmark.websiteURL!));
-                              },
-                              icon: Icon(Icons.link),
-                              label: Text('Website'),
-                            ),
-                          if (widget.landmark.wikipediaURL != null)
-                            TextButton.icon(
-                              onPressed: () async {
-                                // open a browser with the wikipedia link
-                                await launchUrl(Uri.parse(widget.landmark.wikipediaURL!));
-                              },
-                              icon: Icon(Icons.book),
-                            label: Text('Wikipedia'),
-                          ),
-                        ],
-                      ),
-                    ),
-                  ],
-                ),
-              ),
-            ),
-          ],
+        // if the image is available, display it on the left side of the card, otherwise only display the text
+        child: widget.landmark.imageURL != null ? splitLayout() : textLayout(),
+      ),
+    );
+  }
+
+  Widget splitLayout() {
+    // If an image is available, display it on the left side of the card
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Container(
+          // the image on the left
+          width: 160,
+          height: 160,
+
+          child: CachedNetworkImage(
+            imageUrl: widget.landmark.imageURL ?? '',
+            placeholder: (context, url) => Center(child: CircularProgressIndicator()),
+            errorWidget: (context, error, stackTrace) => Icon(Icons.question_mark_outlined),
+            fit: BoxFit.cover,
+          ),
         ),
+        Flexible(
+          child: textLayout(),
+        ),
+      ],
+    );
+  }
+
+  Widget textLayout() {
+    return Padding(
+      padding: EdgeInsets.all(10),
+      child: Column(
+        children: [
+          Row(
+            children: [
+              Flexible(
+                child: Text(
+                  widget.landmark.name,
+                  style: const TextStyle(
+                    fontSize: 18,
+                    fontWeight: FontWeight.bold,
+                  ),
+                  maxLines: 2,
+                ),
+              )
+            ],
+          ),
+          if (widget.landmark.nameEN != null)
+            Row(
+              children: [
+                Flexible(
+                  child: Text(
+                    widget.landmark.nameEN!,
+                    style: const TextStyle(
+                      fontSize: 16,
+                    ),
+                    maxLines: 1,
+                  ),
+                )
+              ],
+            ),
+          Padding(padding: EdgeInsets.only(top: 10)),
+          Align(
+            alignment: Alignment.centerLeft,
+            child: SingleChildScrollView(
+              // allows the buttons to be scrolled
+              scrollDirection: Axis.horizontal,
+              child: Wrap(
+                spacing: 10,
+                // show the type, the website, and the wikipedia link as buttons/labels in a row
+                children: [
+                  TextButton.icon(
+                    onPressed: () {},
+                    icon: widget.landmark.type.icon,
+                    label: Text(widget.landmark.type.name),
+                  ),
+                  if (widget.landmark.duration != null && widget.landmark.duration!.inMinutes > 0)
+                    TextButton.icon(
+                      onPressed: () {},
+                      icon: Icon(Icons.hourglass_bottom),
+                      label: Text('${widget.landmark.duration!.inMinutes} minutes'),
+                    ),
+                  if (widget.landmark.websiteURL != null)
+                    TextButton.icon(
+                      onPressed: () async {
+                        // open a browser with the website link
+                        await launchUrl(Uri.parse(widget.landmark.websiteURL!));
+                      },
+                      icon: Icon(Icons.link),
+                      label: Text('Website'),
+                    ),
+                  PopupMenuButton(
+                    icon: Icon(Icons.settings),
+                    style: TextButtonTheme.of(context).style,
+                    itemBuilder: (context) => [
+                      PopupMenuItem(
+                        child: ListTile(
+                          leading: Icon(Icons.delete),
+                          title: Text('Delete'),
+                          onTap: () async {
+                            widget.parentTrip.removeLandmark(widget.landmark);
+                            rootScaffoldMessengerKey.currentState!.showSnackBar(
+                              SnackBar(content: Text("We won't show ${widget.landmark.name} again"))
+                            );
+                          },
+                        ),
+                      ),
+                      PopupMenuItem(
+                        child: ListTile(
+                          leading: Icon(Icons.star),
+                          title: Text('Favorite'),
+                          onTap: () async {
+                            // delete the landmark
+                            // await deleteLandmark(widget.landmark);
+                          },
+                        ),
+                      ),
+                    ],
+                  )
+                    
+                ],
+              ),
+            ),
+          ),
+        ],
       ),
     );
   }

frontend/lib/modules/new_trip_button.dart

@@ -1,5 +1,5 @@
-import 'package:anyway/layout.dart';
 import 'package:anyway/main.dart';
+import 'package:anyway/pages/current_trip.dart';
 import 'package:anyway/structs/preferences.dart';
 import 'package:anyway/structs/trip.dart';
 import 'package:anyway/utils/fetch_trip.dart';
@@ -57,7 +57,7 @@ class _NewTripButtonState extends State<NewTripButton> {
       fetchTrip(trip, widget.preferences);
       Navigator.of(context).push(
         MaterialPageRoute(
-          builder: (context) => BasePage(mainScreen: "map", trip: trip)
+          builder: (context) => TripPage(trip: trip)
         )
       );
     }

frontend/lib/modules/new_trip_location_search.dart

@@ -9,6 +9,15 @@ import 'package:flutter/material.dart';
 import 'package:geolocator/geolocator.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
+const Map<String, List> debugLocations = {
+  'paris': [48.8575, 2.3514],
+  'london': [51.5074, -0.1278],
+  'new york': [40.7128, -74.0060],
+  'tokyo': [35.6895, 139.6917],
+};
+
+
+
 class NewTripLocationSearch extends StatefulWidget {
   Future<SharedPreferences> prefs = SharedPreferences.getInstance();
   Trip trip;
@@ -27,26 +36,35 @@ class _NewTripLocationSearchState extends State<NewTripLocationSearch> {
 
   setTripLocation (String query) async {
     List<Location> locations = [];
+    Location startLocation;
     log('Searching for: $query');
-    
-    try{
-      locations = await locationFromAddress(query);
-    } catch (e) {
-      log('No results found for: $query : $e');
+    if (GeocodingPlatform.instance != null) {
+      locations.addAll(await locationFromAddress(query));
     }
 
     if (locations.isNotEmpty) {
-      Location location = locations.first;
-      widget.trip.landmarks.clear();
-      widget.trip.addLandmark(
-        Landmark(
-          uuid: 'pending',
-          name: query,
-          location: [location.latitude, location.longitude],
-          type: typeStart
-        )
+      startLocation = locations.first;
+    } else {
+      log('No results found for: $query. Is geocoding available?');
+      log('Setting Fallback location');
+      List coordinates = debugLocations[query.toLowerCase()] ?? [48.8575, 2.3514];
+      startLocation = Location(
+        latitude: coordinates[0],
+        longitude: coordinates[1],
+        timestamp: DateTime.now(),
       );
     }
+
+    widget.trip.landmarks.clear();
+    widget.trip.addLandmark(
+      Landmark(
+        uuid: 'pending',
+        name: query,
+        location: [startLocation.latitude, startLocation.longitude],
+        type: typeStart
+      )
+    );
+
   }
 
   late Widget locationSearchBar = SearchBar(

frontend/lib/modules/new_trip_map.dart

@@ -26,7 +26,7 @@ class _NewTripMapState extends State<NewTripMap> {
     target: LatLng(48.8566, 2.3522),
     zoom: 11.0,
   );
-  late GoogleMapController _mapController;
+  GoogleMapController? _mapController;
   final Set<Marker> _markers = <Marker>{};
 
   _onLongPress(LatLng location) {
@@ -56,11 +56,15 @@ class _NewTripMapState extends State<NewTripMap> {
           ),
         )
       );
-      _mapController.moveCamera(
-        CameraUpdate.newLatLng(
-          LatLng(landmark.location[0], landmark.location[1])
-        )
-      );
+      // check if the controller is ready
+
+      if (_mapController != null) {
+        _mapController!.animateCamera(
+          CameraUpdate.newLatLng(
+            LatLng(landmark.location[0], landmark.location[1])
+          )
+        );
+      }
       setState(() {});
     }
   }

frontend/lib/modules/onboarding_card.dart

@@ -2,13 +2,11 @@ import 'package:flutter/material.dart';
 import 'package:flutter_svg/flutter_svg.dart';
 
 class OnboardingCard extends StatelessWidget {
-  int index;
-  String title;
-  String description;
-  String imagePath;
+  final String title;
+  final String description;
+  final String imagePath;
 
-  OnboardingCard({
-    required this.index,
+  const OnboardingCard({
     required this.title,
     required this.description,
     required this.imagePath,
@@ -16,41 +14,35 @@ class OnboardingCard extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    Color baseColor = Theme.of(context).colorScheme.secondary;
-    // have a different color for each card, incrementing the hue
-    Color currentColor = baseColor.withAlpha(baseColor.alpha - index * 30);
-    return Container(
-      color: currentColor,
-      alignment: Alignment.center,
-      child: Padding(
-        padding: EdgeInsets.all(20),
-        child: Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            Text(
-              title,
-              style: TextStyle(
-                fontSize: 24,
-                fontWeight: FontWeight.bold,
-                color: Colors.white,
-              ),
+    
+    return Padding(
+      padding: EdgeInsets.all(20),
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Text(
+            title,
+            style: TextStyle(
+              fontSize: 24,
+              fontWeight: FontWeight.bold,
+              color: Colors.white,
             ),
-            Padding(padding: EdgeInsets.only(top: 20)),
-            SvgPicture.asset(
-              imagePath,
-              height: 200,
-            ),
-            Padding(padding: EdgeInsets.only(top: 20)),
-            Text(
-              description,
-              style: TextStyle(
-                fontSize: 16,
-              ),
+          ),
+          Padding(padding: EdgeInsets.only(top: 20)),
+          SvgPicture.asset(
+            imagePath,
+            height: 200,
+          ),
+          Padding(padding: EdgeInsets.only(top: 20)),
+          Text(
+            description,
+            style: TextStyle(
+              fontSize: 16,
             ),
+          ),
 
-          ]
-        ),
-      )
+        ]
+      ),
     );
   }
 }

frontend/lib/modules/step_between_landmarks.dart

@@ -19,8 +19,7 @@ class StepBetweenLandmarks extends StatefulWidget {
 class _StepBetweenLandmarksState extends State<StepBetweenLandmarks> {
   @override
   Widget build(BuildContext context) {
-    int timeRounded = 5 * ((widget.current.tripTime?.inMinutes ?? 0) ~/ 5);
-    // ~/ is integer division (rounding)
+    int time = widget.current.tripTime?.inMinutes ?? 0;
     return Container(
       margin: EdgeInsets.all(10),
       padding: EdgeInsets.all(10),
@@ -34,7 +33,7 @@ class _StepBetweenLandmarksState extends State<StepBetweenLandmarks> {
           Column(
             children: [
               Icon(Icons.directions_walk),
-              Text("~$timeRounded min", style: TextStyle(fontSize: 10)),
+              Text("$time min", style: TextStyle(fontSize: 10)),
             ],
           ),
           Spacer(),

frontend/lib/modules/trips_saved_list.dart

@@ -1,11 +1,12 @@
+import 'package:anyway/pages/current_trip.dart';
+import 'package:anyway/utils/load_trips.dart';
 import 'package:flutter/material.dart';
 
-import 'package:anyway/layout.dart';
 import 'package:anyway/structs/trip.dart';
 
 
 class TripsOverview extends StatefulWidget {
-  final Future<List<Trip>> trips;
+  final SavedTrips trips;
   const TripsOverview({
     super.key,
     required this.trips,
@@ -16,50 +17,34 @@ class TripsOverview extends StatefulWidget {
 }
 
 class _TripsOverviewState extends State<TripsOverview> {
-
-  Widget listBuild (BuildContext context, AsyncSnapshot<List<Trip>> snapshot) {
+  Widget listBuild (BuildContext context, SavedTrips trips) {
     List<Widget> children;
-    if (snapshot.hasData) {
-      children = List<Widget>.generate(snapshot.data!.length, (index) {
-        Trip trip = snapshot.data![index];
-        return ListTile(
-          title: FutureBuilder(
-            future: trip.cityName,
-            builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
-              if (snapshot.hasData) {
-                return Text("Trip to ${snapshot.data}");
-              } else if (snapshot.hasError) {
-                return Text("Error: ${snapshot.error}");
-              } else {
-                return const Text("Trip to ...");
-              }
-            },
-          ),
-          leading: Icon(Icons.pin_drop),
-          onTap: () {
-            Navigator.of(context).push(
-              MaterialPageRoute(
-                builder: (context) => BasePage(mainScreen: "map", trip: trip)
-              )
-            );
+    List<Trip> items = trips.trips;
+    children = List<Widget>.generate(items.length, (index) {
+      Trip trip = items[index];
+      return ListTile(
+        title: FutureBuilder(
+          future: trip.cityName,
+          builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
+            if (snapshot.hasData) {
+              return Text("Trip to ${snapshot.data}");
+            } else if (snapshot.hasError) {
+              return Text("Error: ${snapshot.error}");
+            } else {
+              return const Text("Trip to ...");
+            }
           },
-        );
-      });
-    } else if (snapshot.hasError) {
-      children = [
-        const Icon(
-          Icons.error_outline,
-          color: Colors.red,
-          size: 60,
         ),
-        Padding(
-          padding: const EdgeInsets.only(top: 16),
-          child: Text('Error: ${snapshot.error}'),
-        ),
-      ];
-    } else {
-      children = [Center(child: CircularProgressIndicator())];
-    }
+        leading: Icon(Icons.pin_drop),
+        onTap: () {
+          Navigator.of(context).push(
+            MaterialPageRoute(
+              builder: (context) => TripPage(trip: trip)
+            )
+          );
+        },
+      );
+    });
 
     return ListView(
       children: children,
@@ -69,9 +54,11 @@ class _TripsOverviewState extends State<TripsOverview> {
 
   @override
   Widget build(BuildContext context) {
-    return FutureBuilder(
-      future: widget.trips,
-      builder: listBuild,
+    return ListenableBuilder(
+      listenable: widget.trips,
+      builder: (BuildContext context, Widget? child) {
+        return listBuild(context, widget.trips);
+      }
     );
   }
-}
+}

frontend/lib/pages/base_page.dart

@@ -1,3 +1,6 @@
+import 'package:anyway/main.dart';
+import 'package:anyway/modules/help_dialog.dart';
+import 'package:anyway/pages/current_trip.dart';
 import 'package:anyway/pages/settings.dart';
 import 'package:flutter/material.dart';
 
@@ -8,22 +11,24 @@ import 'package:anyway/modules/trips_saved_list.dart';
 import 'package:anyway/utils/load_trips.dart';
 
 import 'package:anyway/pages/new_trip_location.dart';
-import 'package:anyway/pages/current_trip.dart';
 import 'package:anyway/pages/onboarding.dart';
 
 
 
 
-// BasePage is the scaffold that holds all other pages
-// A side drawer is used to switch between pages
+// BasePage is the scaffold that holds a child page and a side drawer
+// The side drawer is the main way to switch between pages
+
 class BasePage extends StatefulWidget {
-  final String mainScreen;
-  final Trip? trip;
+  final Widget mainScreen;
+  final Widget title;
+  final List<String> helpTexts;
 
   const BasePage({
     super.key,
     required this.mainScreen,
-    this.trip,
+    this.title = const Text(APP_NAME),
+    this.helpTexts = const [],
   });
 
   @override
@@ -34,53 +39,25 @@ class _BasePageState extends State<BasePage> {
 
   @override
   Widget build(BuildContext context) {
-    Widget currentView = const Text("loading...");
-    Future<List<Trip>> trips = loadTrips();
-    
-    
-    if (widget.mainScreen == "map") {
-      if (widget.trip != null) {
-        currentView = TripPage(trip: widget.trip!);
-      } else {
-        currentView = FutureBuilder(
-          future: trips,
-          builder: (context, snapshot) {
-            if (snapshot.hasData) {
-              List<Trip> availableTrips = snapshot.data!;
-              if (availableTrips.isNotEmpty) {
-                return TripPage(trip: availableTrips[0]);
-              } else {
-                return Scaffold(
-                  body: Center(
-                    child: Text("Wow, so empty!"),
-                  ),
-                  floatingActionButton: FloatingActionButton.extended(
-                    onPressed: () {
-                      Navigator.of(context).push(
-                        MaterialPageRoute(
-                          builder: (context) => const NewTripPage()
-                        )
-                      );
-                    },
-                    label: Text("Plan a trip"),
-                  ),
-                );
-              }
-            } else {
-              return const Text("loading...");
-            }
-          },
-        );
-      }
-    } else if (widget.mainScreen == "tutorial") {
-      currentView = OnboardingPage();
-    } else if (widget.mainScreen == "settings") {
-      currentView = SettingsPage();
-    }
+    savedTrips.loadTrips();
+
 
     return Scaffold(
-      appBar: AppBar(title: Text(APP_NAME)),
-      body: Center(child: currentView),
+      appBar: AppBar(
+        title: widget.title,
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.help),
+            tooltip: 'Help',
+            onPressed: () {
+              if (widget.helpTexts.isNotEmpty) {
+                helpDialog(context, widget.helpTexts[0], widget.helpTexts[1]);
+              }
+            }
+          ),
+        ],
+      ),
+      body: Center(child: widget.mainScreen),
       drawer: Drawer(
         child: Column(
           children: [
@@ -104,7 +81,8 @@ class _BasePageState extends State<BasePage> {
             ListTile(
               title: const Text('Your Trips'),
               leading: const Icon(Icons.map),
-              selected: widget.mainScreen == "map",
+              // TODO: this is not working!
+              selected: widget.mainScreen is TripPage,
               onTap: () {},
               trailing: ElevatedButton(
                 onPressed: () {
@@ -122,11 +100,11 @@ class _BasePageState extends State<BasePage> {
             // through the options in the drawer if there isn't enough vertical
             // space to fit everything.
             Expanded(
-              child: TripsOverview(trips: trips),
+              child: TripsOverview(trips: savedTrips),
             ),
             ElevatedButton(
               onPressed: () async {
-                removeAllTripsFromPrefs();
+                savedTrips.clearTrips();
               },
               child: const Text('Clear trips'),
             ),
@@ -134,11 +112,12 @@ class _BasePageState extends State<BasePage> {
             ListTile(
               title: const Text('How to use'),
               leading: Icon(Icons.help),
-              selected: widget.mainScreen == "tutorial",
+              // TODO: this is not working!
+              selected: widget.mainScreen is OnboardingPage,
               onTap: () {
                 Navigator.of(context).push(
                   MaterialPageRoute(
-                    builder: (context) => BasePage(mainScreen: "tutorial")
+                    builder: (context) => OnboardingPage()
                   )
                 );
               },
@@ -148,11 +127,12 @@ class _BasePageState extends State<BasePage> {
             ListTile(
               title: const Text('Settings'),
               leading: const Icon(Icons.settings),
-              selected: widget.mainScreen == "settings",
+              // TODO: this is not working!
+              selected: widget.mainScreen is SettingsPage,
               onTap: () {
                 Navigator.of(context).push(
                   MaterialPageRoute(
-                    builder: (context) => BasePage(mainScreen: "settings")
+                    builder: (context) => SettingsPage()
                   )
                 );
               },

frontend/lib/pages/current_trip.dart

@@ -1,4 +1,5 @@
 import 'package:anyway/constants.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:flutter/material.dart';
 import 'package:sliding_up_panel/sliding_up_panel.dart';
 
@@ -10,7 +11,7 @@ final Shader textGradient = APP_GRADIENT.createShader(Rect.fromLTWH(0.0, 0.0, 20
 TextStyle greeterStyle = TextStyle(
   foreground: Paint()..shader = textGradient,
   fontWeight: FontWeight.bold,
-  fontSize: 26
+  fontSize: 25
 );
 
 
@@ -31,7 +32,8 @@ class _TripPageState extends State<TripPage> {
 
   @override
   Widget build(BuildContext context) {
-    return SlidingUpPanel(
+    return BasePage(
+      mainScreen: SlidingUpPanel(
         // use panelBuilder instead of panel so that we can reuse the scrollcontroller for the listview
         panelBuilder: (scrollcontroller) => CurrentTripPanel(controller: scrollcontroller, trip: widget.trip),
         // using collapsed and panelBuilder seems to show both at the same time, so we include the greeter in the panelBuilder
@@ -41,7 +43,7 @@ class _TripPageState extends State<TripPage> {
         maxHeight: MediaQuery.of(context).size.height * TRIP_PANEL_MAX_HEIGHT,
         // padding in this context is annoying: it offsets the notion of vertical alignment.
         // children that want to be centered vertically need to have their size adjusted by 2x the padding
-        padding: const EdgeInsets.all(10.0),
+        // padding: const EdgeInsets.all(10.0),
         // Panel snapping should not be disabled because it significantly improves the user experience
         // panelSnapping: false
         borderRadius: const BorderRadius.only(topLeft: Radius.circular(25), topRight: Radius.circular(25)),
@@ -52,6 +54,13 @@ class _TripPageState extends State<TripPage> {
             color: Colors.black,
           )
         ],
+      ),
+      title: FutureBuilder(
+        future: widget.trip.cityName,
+        builder: (context, snapshot) => Text(
+          'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
+        )
+      ),
     );
   }
 }

frontend/lib/pages/new_trip_location.dart

@@ -1,5 +1,5 @@
-import 'package:anyway/modules/new_trip_button.dart';
 import 'package:anyway/modules/new_trip_options_button.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:flutter/material.dart';
 
 import "package:anyway/structs/trip.dart";
@@ -19,23 +19,28 @@ class _NewTripPageState extends State<NewTripPage> {
   final TextEditingController lonController = TextEditingController();
   Trip trip = Trip();
 
+
   @override
   Widget build(BuildContext context) {
     // floating search bar and map as a background
-    return Scaffold(
-      appBar: AppBar(
-        title: const Text('New Trip'),
+    return BasePage(
+      mainScreen: Scaffold(
+        body: Stack(
+          children: [
+            NewTripMap(trip),
+            Padding(
+              padding: EdgeInsets.all(15),
+              child: NewTripLocationSearch(trip),
+            ),
+          ],
+        ),
+        floatingActionButton: NewTripOptionsButton(trip: trip),
       ),
-      body: Stack(
-        children: [
-          NewTripMap(trip),
-          Padding(
-            padding: EdgeInsets.all(15),
-            child: NewTripLocationSearch(trip),
-          ),
-        ],
-      ),
-      floatingActionButton: NewTripOptionsButton(trip: trip),
+      title: Text("New Trip"),
+      helpTexts: [
+        "Setting the start location",
+        "To set the starting point, type a city name in the search bar. You can also navigate the map like you're used to and long press anywhere to set a starting point."
+      ],
     );
   }
 }

frontend/lib/pages/new_trip_preferences.dart

@@ -1,4 +1,5 @@
 import 'package:anyway/modules/new_trip_button.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:anyway/structs/preferences.dart';
 import 'package:anyway/structs/trip.dart';
 import 'package:flutter/cupertino.dart';
@@ -19,41 +20,54 @@ class _NewTripPreferencesPageState extends State<NewTripPreferencesPage> {
 
   @override
   Widget build(BuildContext context) {
-    return Scaffold(
-      body: ListView(
-        children: [
-          // Center(
-          //   child: CircleAvatar(
-          //     radius: 100,
-          //     child: Icon(Icons.person, size: 100),
-          //   )
-          // ),
-          Padding(padding: EdgeInsets.only(top: 30)),
-          Center(
-            child: FutureBuilder(
-              future: widget.trip.cityName,
-              builder: (context, snapshot) => Text(
-                'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
-                style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold)
-              )
-            )
-          ),
+    return BasePage(
+      mainScreen: Scaffold(
+        body: ListView(
+          children: [
+            // Center(
+            //   child: CircleAvatar(
+            //     radius: 100,
+            //     child: Icon(Icons.person, size: 100),
+            //   )
+            // ),
+            // Padding(padding: EdgeInsets.only(top: 30)),
+            // Center(
+            //   child: FutureBuilder(
+            //     future: widget.trip.cityName,
+            //     builder: (context, snapshot) => Text(
+            //       'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
+            //       style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold)
+            //     )
+            //   )
+            // ),
 
-          Center(
-            child: Padding(
-            padding: EdgeInsets.only(left: 10, right: 10, top: 20, bottom: 0),
-              child: Text('Tell us about your ideal trip.', style: TextStyle(fontSize: 18))
+            Center(
+              child: Padding(
+              padding: EdgeInsets.only(left: 10, right: 10, top: 20, bottom: 0),
+                child: Text('Tell us about your ideal trip.', style: TextStyle(fontSize: 18))
+              ),
             ),
-          ),
 
-          Divider(indent: 25, endIndent: 25, height: 50),
+            Divider(indent: 25, endIndent: 25, height: 50),
 
-          durationPicker(preferences.maxTime),
+            durationPicker(preferences.maxTime),
 
-          preferenceSliders([preferences.sightseeing, preferences.shopping, preferences.nature]),
-        ]
+            preferenceSliders([preferences.sightseeing, preferences.shopping, preferences.nature]),
+          ]
+        ),
+        floatingActionButton: NewTripButton(trip: widget.trip, preferences: preferences),
       ),
-      floatingActionButton: NewTripButton(trip: widget.trip, preferences: preferences),
+      
+      title: FutureBuilder(
+        future: widget.trip.cityName,
+        builder: (context, snapshot) => Text(
+          'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
+        )
+      ),
+      helpTexts: [
+        'Trip preferences',
+        'Set your preferences for this trip. These will be used to generate a custom itinerary.'
+      ],
     );
   }
 

frontend/lib/pages/onboarding.dart

@@ -1,7 +1,33 @@
+import 'dart:ui';
+
+import 'package:anyway/constants.dart';
 import 'package:anyway/modules/onboarding_card.dart';
 import 'package:anyway/pages/new_trip_location.dart';
 import 'package:flutter/material.dart';
 
+const List<Widget> onboardingCards = [
+  OnboardingCard(
+    title: "Welcome to anyway!",
+    description: "Anyway helps you plan a city trip that suits your wishes.",
+    imagePath: "assets/city.svg"
+  ),
+  OnboardingCard(
+    title: "Find your way",
+    description: "Bored by churches? No problem! Hate shopping? No worries! Instead of suggesting the generic trips that bore you, anyway will try to give you recommendations that really suit you.",
+    imagePath: "assets/plan.svg"
+  ),
+  OnboardingCard(
+    title: "Change your mind",
+    description: "Feet get sore, the weather changes. Anyway understands that! Move or remove destinations, visit hidden gems along your journey, do your own thing. Anyway adapts to your spontaneous decisions.",
+    imagePath: "assets/cat.svg"
+  ),
+  OnboardingCard(
+    title: "Feeling lost?",
+    description: "Whenever you are confused or need help with the app, look out for the question mark in the top right corner. Help is just a tap away!",
+    imagePath: "assets/confused.svg"
+  ),
+];
+
 class OnboardingPage extends StatefulWidget {
   const OnboardingPage({super.key});
 
@@ -10,37 +36,83 @@ class OnboardingPage extends StatefulWidget {
 }
 
 class _OnboardingPageState extends State<OnboardingPage> {
+  final PageController _controller = PageController();
+
   @override
   Widget build(BuildContext context) {
-    final PageController _controller = PageController();
     return Scaffold(
       body: Stack(
         children: [
+          AnimatedBuilder(
+            animation: _controller,
+            builder: (context, child) {
+              return Stack(
+                children: [
+                  Container(
+                    decoration: BoxDecoration(
+                      gradient: LinearGradient(
+                        begin: Alignment.topLeft,
+                        end: Alignment.bottomRight,
+                        colors: APP_GRADIENT.colors,
+                        stops: [
+                          (_controller.hasClients ? _controller.page ?? _controller.initialPage : _controller.initialPage) / onboardingCards.length,
+                          (_controller.hasClients ? _controller.page ?? _controller.initialPage + 1 : _controller.initialPage + 1) / onboardingCards.length,
+                        ],
+                      ),
+                    ),
+                  ),
+                  BackdropFilter(
+                    filter: ImageFilter.blur(sigmaX: 100, sigmaY: 100),
+                    child: Container(
+                      color: Colors.black.withOpacity(0),
+                    ),
+                  ),
+                ],
+              );
+            },
+          ),
           PageView(
-            // horizontally scrollable list of pages
             controller: _controller,
-            
-            children: [
-              OnboardingCard(index: 1, title: "Welcome to anyway!", description: "Anyway helps you plan a city trip that suits your wishes.", imagePath: "assets/city.svg"),
-              OnboardingCard(index: 2, title: "Find your way", description: "Bored by churches? No problem! Hate shopping? No worries! More than showing you the typical 'must-sees' of a city, anyway will try to give you recommendations that really suit you.", imagePath: "assets/plan.svg"),
-              OnboardingCard(index: 3, title: "Change your mind", description: "Life happens when you're busy making plans. Anyway understands that! Move or remove destinations, visit hidden gems along your journey, do your own thing. Anyway adapts to your spontaneous decisions.", imagePath: "assets/cat.svg"),
-            ],
+            children: List.generate(
+              onboardingCards.length,
+              (index) {
+                return Container(
+                  alignment: Alignment.center,
+                  child: onboardingCards[index],
+                );
+              }
+            ),
           ),
         ],
       ),
-      floatingActionButton: FloatingActionButton(
-         onPressed: () {
-            if (_controller.page == 2) {
-              Navigator.of(context).push(
-                MaterialPageRoute(
-                  builder: (context) => const NewTripPage()
-                )
+      floatingActionButton: FloatingActionButton.extended(
+        onPressed: () {
+          if (_controller.page == onboardingCards.length - 1) {
+            Navigator.of(context).push(
+              MaterialPageRoute(
+                builder: (context) => const NewTripPage()
+              )
+            );
+          } else {
+            _controller.nextPage(duration: Duration(milliseconds: 500), curve: Curves.ease);
+          }
+        },
+        label: AnimatedBuilder(
+          animation: _controller,
+          builder: (context, child) {
+            if ((_controller.page ?? _controller.initialPage) == onboardingCards.length - 1) {
+              return Row(
+                children: [
+                  const Text("Start planning!"),
+                  Padding(padding: const EdgeInsets.only(right: 8.0)),
+                  const Icon(Icons.map_outlined)
+                ],
               );
             } else {
-              _controller.nextPage(duration: Duration(milliseconds: 500), curve: Curves.ease);
+              return const Icon(Icons.arrow_forward);
             }
-          },
-          child: Icon(Icons.arrow_forward),
+          }
+        )
       ),
     );
   }

frontend/lib/pages/settings.dart

@@ -1,5 +1,6 @@
 import 'package:anyway/constants.dart';
 import 'package:anyway/main.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:flutter/material.dart';
 import 'package:permission_handler/permission_handler.dart';
 import 'package:shared_preferences/shared_preferences.dart';
@@ -16,30 +17,37 @@ class SettingsPage extends StatefulWidget {
 class _SettingsPageState extends State<SettingsPage> {
   @override
   Widget build(BuildContext context) {
-    return ListView(
-      padding: EdgeInsets.all(15),
-      children: [
-        // First a round, centered image
-        Center(
-          child: CircleAvatar(
-            radius: 75,
-            child: Icon(Icons.settings, size: 100),
-          )
-        ),
-        Center(
-          child: Text('Global settings', style: TextStyle(fontSize: 24))
-        ),
+    return BasePage(
+      mainScreen: ListView(
+        padding: EdgeInsets.all(15),
+        children: [
+          // First a round, centered image
+          Center(
+            child: CircleAvatar(
+              radius: 75,
+              child: Icon(Icons.settings, size: 100),
+            )
+          ),
+          Center(
+            child: Text('Global settings', style: TextStyle(fontSize: 24))
+          ),
 
-        Divider(indent: 25, endIndent: 25, height: 50),
+          Divider(indent: 25, endIndent: 25, height: 50),
 
-        darkMode(),
-        setLocationUsage(),
-        setDebugMode(),
+          darkMode(),
+          setLocationUsage(),
+          setDebugMode(),
 
-        Divider(indent: 25, endIndent: 25, height: 50),
+          Divider(indent: 25, endIndent: 25, height: 50),
 
-        privacyInfo(),
-      ]
+          privacyInfo(),
+        ]
+      ),
+      title: Text('Settings'),
+      helpTexts: [
+        'Settings',
+        'Preferences set in this page are global and will affect the entire application.'
+      ],
     );
   }
 
@@ -169,7 +177,9 @@ class _SettingsPageState extends State<SettingsPage> {
     return Center(
       child: Column(
         children: [
-          Text('Our privacy policy is available under:'),
+          Text('AnyWay does not collect or store any of the data that is submitted via the app. The location of your trip is not stored. The location feature is only used to show your current location on the map, it is not transmitted to our servers.', textAlign: TextAlign.center),
+          Padding(padding: EdgeInsets.only(top: 3)),
+          Text('Our full privacy policy is available under:', textAlign: TextAlign.center),
           
           TextButton.icon(
             icon: Icon(Icons.info),

frontend/lib/structs/landmark.dart

@@ -24,8 +24,7 @@ final class Landmark extends LinkedListEntry<Landmark>{
   // description to be shown in the overview
   final String? nameEN;
   final String? websiteURL;
-  final String? wikipediaURL;
-  final String? imageURL;
+  String? imageURL; // not final because it can be patched
   final String? description;
   final Duration? duration;
   final bool? visited;
@@ -44,7 +43,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
 
     this.nameEN,
     this.websiteURL,
-    this.wikipediaURL,
     this.imageURL,
     this.description,
     this.duration,
@@ -70,7 +68,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
       final isSecondary = json['is_secondary'] as bool?;
       final nameEN = json['name_en'] as String?;
       final websiteURL = json['website_url'] as String?;
-      final wikipediaURL = json['wikipedia_url'] as String?;
       final imageURL = json['image_url'] as String?;
       final description = json['description'] as String?;
       var duration = Duration(minutes: json['duration'] ?? 0) as Duration?;
@@ -85,7 +82,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
         isSecondary: isSecondary,
         nameEN: nameEN,
         websiteURL: websiteURL,
-        wikipediaURL: wikipediaURL,
         imageURL: imageURL,
         description: description,
         duration: duration,
@@ -112,7 +108,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
     'is_secondary': isSecondary,
     'name_en': nameEN,
     'website_url': websiteURL,
-    'wikipedia_url': wikipediaURL,
     'image_url': imageURL,
     'description': description,
     'duration': duration?.inMinutes,
@@ -130,7 +125,7 @@ class LandmarkType {
   LandmarkType({required this.name, this.icon = const Icon(Icons.location_on)}) {
     switch (name) {
       case 'sightseeing':
-        icon = const Icon(Icons.church);
+        icon = const Icon(Icons.castle);
         break;
       case 'nature':
         icon = const Icon(Icons.eco);

frontend/lib/structs/trip.dart

@@ -113,10 +113,3 @@ LinkedList<Landmark> readLandmarks(SharedPreferences prefs, String? firstUUID) {
   }
   return landmarks;
 }
-
-
-
-void removeAllTripsFromPrefs () async {
-  SharedPreferences prefs = await SharedPreferences.getInstance();
-  prefs.clear();
-}

frontend/lib/utils/fetch_trip.dart

@@ -1,5 +1,6 @@
 import "dart:convert";
 import "dart:developer";
+import "package:anyway/utils/load_landmark_image.dart";
 import 'package:dio/dio.dart';
 
 import 'package:anyway/constants.dart';
@@ -85,6 +86,20 @@ fetchTrip(
 }
 
 
+patchLandmarkImage(Landmark landmark) async {
+  // patch the landmark to include an image from an external source
+  if (landmark.imageURL == null) {
+    String? newUrl = await getImageUrlFromName(landmark.name);
+    if (newUrl != null) {
+      landmark.imageURL = newUrl;
+    }
+  } else if (landmark.imageURL!.contains("photos.app.goo.gl")) {
+    // the image is a google photos link, we should get the image behind the link
+    String? newUrl = await getImageUrlFromGooglePhotos(landmark.imageURL!);
+    // also set the new url if it is null
+    landmark.imageURL = newUrl; 
+  }
+}
 
 Future<(Landmark, String?)> fetchLandmark(String uuid) async {
   final response = await dio.get(
@@ -101,5 +116,7 @@ Future<(Landmark, String?)> fetchLandmark(String uuid) async {
   log(response.data.toString());
   Map<String, dynamic> json = response.data;
   String? nextUUID = json["next_uuid"];
-  return (Landmark.fromJson(json), nextUUID);
+  Landmark landmark = Landmark.fromJson(json);
+  patchLandmarkImage(landmark);
+  return (landmark, nextUUID);
 }

frontend/lib/utils/get_first_page.dart

@@ -0,0 +1,41 @@
+import 'package:anyway/pages/current_trip.dart';
+import 'package:anyway/pages/onboarding.dart';
+import 'package:anyway/structs/trip.dart';
+import 'package:anyway/utils/load_trips.dart';
+import 'package:flutter/material.dart';
+
+Widget getFirstPage() {
+  SavedTrips trips = SavedTrips();
+  trips.loadTrips();
+
+  return ListenableBuilder(
+    listenable: trips,
+    builder: (BuildContext context, Widget? child) {
+      List<Trip> items = trips.trips;
+      if (items.isNotEmpty) {
+        return TripPage(trip: items[0]);
+      } else {
+        return OnboardingPage();
+      }
+    }
+  );
+  // Future<List<Trip>> trips = loadTrips();
+  // // test if there are any active trips
+  // // if there are, return the trip list
+  // // if there are not, return the onboarding page
+  // return FutureBuilder(
+  //   future: trips,
+  //   builder: (context, snapshot) {
+  //     if (snapshot.hasData) {
+  //       List<Trip> availableTrips = snapshot.data!;
+  //       if (availableTrips.isNotEmpty) {
+  //         return TripPage(trip: availableTrips[0]);
+  //       } else {
+  //         return OnboardingPage();
+  //       }
+  //     } else {
+  //       return CircularProgressIndicator();
+  //     }
+  //   }
+  // );
+}

frontend/lib/utils/load_landmark_image.dart

@@ -0,0 +1,71 @@
+import 'dart:developer';
+
+import 'package:dio/dio.dart';
+import 'package:fuzzywuzzy/fuzzywuzzy.dart';
+import 'dart:convert';
+
+import 'package:fuzzywuzzy/model/extracted_result.dart';
+
+const String baseUrl = "https://en.wikipedia.org/w/api.php";
+final Dio dio = Dio();
+
+Future<int?> bestPageMatch(String title) async {
+    final response = await dio.get(baseUrl, queryParameters: {
+        "action": "query",
+        "format": "json",
+        "list": "prefixsearch",
+        "pssearch": title,
+    });
+
+    final data = jsonDecode(response.toString());
+    log(data.toString());
+    final List<dynamic> results = data["query"]["prefixsearch"] ?? {};
+    final Map<String, int> titlesAndIds = {
+        for (var d in results) d["title"]: d["pageid"]
+    };
+    if (titlesAndIds.isEmpty) {
+        log("No pages found for $title");
+        return null;
+    }
+
+    // after the empty check, we can safely assume that there is a best match
+    final ExtractedResult<String> bestMatch = extractOne(
+      query: title,
+      choices: titlesAndIds.keys.toList(),
+      cutoff: 70,
+    );
+    return titlesAndIds[bestMatch.choice];
+}
+
+Future<String?> getImageUrl(int pageId) async {
+    final response = await dio.get(baseUrl, queryParameters: {
+        "action": "query",
+        "format": "json",
+        "prop": "pageimages",
+        "pageids": pageId,
+        "pithumbsize": 500,
+    });
+
+    final data = jsonDecode(response.toString());
+    final pageData = data["query"]["pages"][pageId.toString()];
+    return pageData["thumbnail"]?["source"];
+}
+
+Future<String?> getImageUrlFromName(String title) async {
+    int? pageId = await bestPageMatch(title);
+    if (pageId == null) {
+        return null;
+    }
+    return await getImageUrl(pageId);
+}
+
+
+Future<String?> getImageUrlFromGooglePhotos(String url) async {
+    // this is a very simple implementation that just gets the image behind the link
+    // it is not guaranteed to work for all google photos links
+    final response = await dio.get(url);
+    final data = response.toString();
+    final int start = data.indexOf("https://lh3.googleusercontent.com");
+    final int end = data.indexOf('"', start);
+    return data.substring(start, end);
+}

frontend/lib/utils/load_trips.dart

@@ -1,19 +1,39 @@
-import 'dart:collection';
-
 import 'package:anyway/structs/trip.dart';
-import 'package:anyway/structs/landmark.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
-Future<List<Trip>> loadTrips() async {
-  SharedPreferences prefs = await SharedPreferences.getInstance();
+import 'package:flutter/foundation.dart';
 
-  List<Trip> trips = [];
-  Set<String> keys = prefs.getKeys();
-  for (String key in keys) {
-    if (key.startsWith('trip_')) {
-      String uuid = key.replaceFirst('trip_', '');
-      trips.add(Trip.fromPrefs(prefs, uuid));
+class SavedTrips extends ChangeNotifier {
+  List<Trip> _trips = [];
+
+  List<Trip> get trips => _trips;
+
+  void loadTrips() async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+
+    List<Trip> trips = [];
+    Set<String> keys = prefs.getKeys();
+    for (String key in keys) {
+      if (key.startsWith('trip_')) {
+        String uuid = key.replaceFirst('trip_', '');
+        trips.add(Trip.fromPrefs(prefs, uuid));
+      }
     }
+    _trips = trips;
+    notifyListeners();
+  }
+
+  void addTrip(Trip trip) async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    trip.toPrefs(prefs);
+    _trips.add(trip);
+    notifyListeners();
+  }
+
+  void clearTrips () async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    prefs.clear();
+    _trips = [];
+    notifyListeners();
   }
-  return trips;
 }

frontend/pubspec.lock

@@ -101,10 +101,10 @@ packages:
     dependency: transitive
     description:
       name: collection
-      sha256: ee67cb0715911d28db6bf4af1026078bd6f0128b07a5f66fb2ed94ec6783c09a
+      sha256: a1ace0a119f20aabc852d165077c036cd864315bd99b7eaa10a60100341941bf
       url: "https://pub.dev"
     source: hosted
-    version: "1.18.0"
+    version: "1.19.0"
   crypto:
     dependency: transitive
     description:
@@ -232,6 +232,14 @@ packages:
     description: flutter
     source: sdk
     version: "0.0.0"
+  fuzzywuzzy:
+    dependency: "direct main"
+    description:
+      name: fuzzywuzzy
+      sha256: "3004379ffd6e7f476a0c2091f38f16588dc45f67de7adf7c41aa85dec06b432c"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
   geocoding:
     dependency: "direct main"
     description:
@@ -404,18 +412,18 @@ packages:
     dependency: transitive
     description:
       name: leak_tracker
-      sha256: "3f87a60e8c63aecc975dda1ceedbc8f24de75f09e4856ea27daf8958f2f0ce05"
+      sha256: "7bb2830ebd849694d1ec25bf1f44582d6ac531a57a365a803a6034ff751d2d06"
       url: "https://pub.dev"
     source: hosted
-    version: "10.0.5"
+    version: "10.0.7"
   leak_tracker_flutter_testing:
     dependency: transitive
     description:
       name: leak_tracker_flutter_testing
-      sha256: "932549fb305594d82d7183ecd9fa93463e9914e1b67cacc34bc40906594a1806"
+      sha256: "9491a714cca3667b60b5c420da8217e6de0d1ba7a5ec322fab01758f6998f379"
       url: "https://pub.dev"
     source: hosted
-    version: "3.0.5"
+    version: "3.0.8"
   leak_tracker_testing:
     dependency: transitive
     description:
@@ -700,7 +708,7 @@ packages:
     dependency: transitive
     description: flutter
     source: sdk
-    version: "0.0.99"
+    version: "0.0.0"
   sliding_up_panel:
     dependency: "direct main"
     description:
@@ -745,10 +753,10 @@ packages:
     dependency: transitive
     description:
       name: stack_trace
-      sha256: "73713990125a6d93122541237550ee3352a2d84baad52d375a4cad2eb9b7ce0b"
+      sha256: "9f47fd3630d76be3ab26f0ee06d213679aa425996925ff3feffdec504931c377"
       url: "https://pub.dev"
     source: hosted
-    version: "1.11.1"
+    version: "1.12.0"
   stream_channel:
     dependency: transitive
     description:
@@ -769,10 +777,10 @@ packages:
     dependency: transitive
     description:
       name: string_scanner
-      sha256: "556692adab6cfa87322a115640c11f13cb77b3f076ddcc5d6ae3c20242bedcde"
+      sha256: "688af5ed3402a4bde5b3a6c15fd768dbf2621a614950b17f04626c431ab3c4c3"
       url: "https://pub.dev"
     source: hosted
-    version: "1.2.0"
+    version: "1.3.0"
   synchronized:
     dependency: transitive
     description:
@@ -793,10 +801,10 @@ packages:
     dependency: transitive
     description:
       name: test_api
-      sha256: "5b8a98dafc4d5c4c9c72d8b31ab2b23fc13422348d2997120294d3bac86b4ddb"
+      sha256: "664d3a9a64782fcdeb83ce9c6b39e78fd2971d4e37827b9b06c3aa1edc5e760c"
       url: "https://pub.dev"
     source: hosted
-    version: "0.7.2"
+    version: "0.7.3"
   typed_data:
     dependency: transitive
     description:
@@ -913,10 +921,10 @@ packages:
     dependency: transitive
     description:
       name: vm_service
-      sha256: "5c5f338a667b4c644744b661f309fb8080bb94b18a7e91ef1dbd343bed00ed6d"
+      sha256: f6be3ed8bd01289b34d679c2b62226f63c0e69f9fd2e50a6b3c1c729a961041b
       url: "https://pub.dev"
     source: hosted
-    version: "14.2.5"
+    version: "14.3.0"
   web:
     dependency: transitive
     description:

frontend/pubspec.yaml

@@ -51,6 +51,7 @@ dependencies:
   flutter_launcher_icons: ^0.13.1
   permission_handler: ^11.3.1
   geolocator: ^13.0.1
+  fuzzywuzzy: ^1.2.0
 
 dev_dependencies:
   flutter_test:

frontend/test/widget_test.dart

@@ -1,30 +0,0 @@
-// This is a basic Flutter widget test.
-//
-// To perform an interaction with a widget in your test, use the WidgetTester
-// utility in the flutter_test package. For example, you can send tap and scroll
-// gestures. You can also use WidgetTester to find child widgets in the widget
-// tree, read text, and verify that the values of widget properties are correct.
-
-import 'package:flutter/material.dart';
-import 'package:flutter_test/flutter_test.dart';
-
-// import 'package:anyway/main.dart';
-import 'package:anyway/layout.dart';
-
-void main() {
-  testWidgets('Counter increments smoke test', (WidgetTester tester) async {
-    // Build our app and trigger a frame.
-    await tester.pumpWidget(BasePage(mainScreen: "map",));
-
-    // Verfiy that the title is displayed
-    expect(find.text('City Nav'), findsOneWidget);
-
-    // Tap the '+' icon and trigger a frame.
-    await tester.tap(find.byIcon(Icons.add));
-    await tester.pump();
-
-    // Verify that our counter has incremented.
-    expect(find.text('0'), findsNothing);
-    expect(find.text('1'), findsOneWidget);
-  });
-}

status

@@ -0,0 +1,48 @@
+error: wrong number of arguments, should be from 1 to 2
+usage: git config [<options>]
+
+Config file location
+    --[no-]global         use global config file
+    --[no-]system         use system config file
+    --[no-]local          use repository config file
+    --[no-]worktree       use per-worktree config file
+    -f, --[no-]file <file>
+                          use given config file
+    --[no-]blob <blob-id> read config from given blob object
+
+Action
+    --[no-]get            get value: name [value-pattern]
+    --[no-]get-all        get all values: key [value-pattern]
+    --[no-]get-regexp     get values for regexp: name-regex [value-pattern]
+    --[no-]get-urlmatch   get value specific for the URL: section[.var] URL
+    --[no-]replace-all    replace all matching variables: name value [value-pattern]
+    --[no-]add            add a new variable: name value
+    --[no-]unset          remove a variable: name [value-pattern]
+    --[no-]unset-all      remove all matches: name [value-pattern]
+    --[no-]rename-section rename section: old-name new-name
+    --[no-]remove-section remove a section: name
+    -l, --[no-]list       list all
+    --[no-]fixed-value    use string equality when comparing values to 'value-pattern'
+    -e, --[no-]edit       open an editor
+    --[no-]get-color      find the color configured: slot [default]
+    --[no-]get-colorbool  find the color setting: slot [stdout-is-tty]
+
+Type
+    -t, --[no-]type <type>
+                          value is given this type
+    --bool                value is "true" or "false"
+    --int                 value is decimal number
+    --bool-or-int         value is --bool or --int
+    --bool-or-str         value is --bool or string
+    --path                value is a path (file or directory name)
+    --expiry-date         value is an expiry date
+
+Other
+    -z, --[no-]null       terminate values with NUL byte
+    --[no-]name-only      show variable names only
+    --[no-]includes       respect include directives on lookup
+    --[no-]show-origin    show origin of config (file, standard input, blob, command line)
+    --[no-]show-scope     show scope of config (worktree, local, global, system, command)
+    --[no-]default <value>
+                          with --get, use default value when missing entry
+