Merge pull request #22 from rodekruis/use_gfm_aois

app/pages/0_AOIs.py

@@ -1,169 +0,0 @@
-import json
-import os
-from pathlib import Path
-
-import folium
-import requests
-import streamlit as st
-from folium.plugins import Draw
-from src.config_parameters import params
-from src.gfm import download_gfm_geojson, get_existing_flood_geojson, sync_cached_data
-from src.utils import (
-    add_about,
-    set_tool_page_style,
-    toggle_menu_button,
-)
-from streamlit_folium import st_folium
-
-# Page configuration
-st.set_page_config(layout="wide", page_title=params["browser_title"])
-
-# If app is deployed hide menu button
-toggle_menu_button()
-
-# Create sidebar
-add_about()
-
-# Page title
-st.markdown("# Flood extent analysis")
-
-# Set page style
-set_tool_page_style()
-
-# Create two rows: top and bottom panel
-row1 = st.container()
-save_area = False
-
-with row1:
-    action_type = st.radio(
-        label="Action Type",
-        options=["See Areas", "Create New Area", "Delete Area"],
-        label_visibility="hidden",
-    )
-
-    # call to render Folium map in Streamlit
-    folium_map = folium.Map([39, 0], zoom_start=8)
-    feat_group_selected_area = folium.FeatureGroup(name="selected_area")
-
-    if action_type == "See Areas":
-        with open("./bboxes/bboxes.json", "r") as f:
-            bboxes = json.load(f)
-        for area_name in bboxes.keys():
-            bbox = bboxes[area_name]["bounding_box"]
-            feat_group_selected_area.add_child(folium.GeoJson(bbox))
-
-        folium_map.fit_bounds(feat_group_selected_area.get_bounds())
-
-    elif action_type == "Create New Area":
-        Draw(
-            export=False,
-            draw_options={
-                "circle": False,
-                "polyline": False,
-                "polygon": False,
-                "rectangle": True,
-                "marker": False,
-                "circlemarker": False,
-            },
-        ).add_to(folium_map)
-
-        new_area_name = st.text_input("Area name")
-        save_area = st.button("Save Area")
-
-    elif action_type == "Delete Area":
-        # Load existing bboxes
-        with open("./bboxes/bboxes.json", "r") as f:
-            bboxes = json.load(f)
-            existing_areas = bboxes.keys()
-
-        area_to_delete = st.selectbox("Choose area to delete", options=existing_areas)
-        bbox = bboxes[area_to_delete]["bounding_box"]
-        feat_group_selected_area.add_child(folium.GeoJson(bbox))
-        folium_map.fit_bounds(feat_group_selected_area.get_bounds())
-
-        delete_area = st.button("Delete")
-
-        if delete_area:
-            with open("./bboxes/bboxes.json", "r") as f:
-                bboxes = json.load(f)
-            bboxes.pop(area_to_delete, None)
-            with open("./bboxes/bboxes.json", "w") as f:
-                json.dump(bboxes, f)
-            st.toast("Area successfully deleted")
-
-    with open("./bboxes/bboxes.json", "r") as f:
-        bboxes = json.load(f)
-
-    # geojson_catania = get_existing_flood_geojson("Catania")
-    # print(geojson_catania)
-    # geojson_selected_area = folium.GeoJson(geojson_catania)
-
-    # feat_group_selected_area.add_child(geojson_selected_area)
-    m = st_folium(
-        folium_map,
-        width=800,
-        height=450,
-        feature_group_to_add=feat_group_selected_area,
-    )
-
-    if save_area:
-        check_drawing = m["all_drawings"] != [] and m["all_drawings"] is not None
-        if not check_drawing:
-            st.error("Please create a region using the rectangle tool on the map.")
-        elif new_area_name == "":
-            st.error("Please provide a name for the new area")
-        else:
-            # Get the drawn area
-            selected_area_geojson = m["all_drawings"][-1]
-
-            print("starting to post new area name to gfm api")
-            coordinates = selected_area_geojson["geometry"]["coordinates"]
-
-            username = os.environ["gfm_username"]
-            password = os.environ["gfm_password"]
-            base_url = "https://api.gfm.eodc.eu/v1"
-
-            # Get token, setup header
-            token_url = f"{base_url}/auth/login"
-
-            payload = {"email": username, "password": password}
-
-            response = requests.post(token_url, json=payload)
-            user_id = response.json()["client_id"]
-            access_token = response.json()["access_token"]
-            header = {"Authorization": f"bearer {access_token}"}
-
-            print("authenticated to API")
-            # Create area of impact
-            create_aoi_url = f"{base_url}/aoi/create"
-
-            payload = {
-                "aoi_name": new_area_name,
-                "description": new_area_name,
-                "user_id": user_id,
-                "geoJSON": {"type": "Polygon", "coordinates": coordinates},
-            }
-
-            r = requests.post(url=create_aoi_url, json=payload, headers=header)
-            print(r.json())
-            print("Posted new AOI")
-
-            print("Writing new area to bbox json")
-            # Load existing bboxes
-            with open("./bboxes/bboxes.json", "r") as f:
-                bboxes = json.load(f)
-
-            # If the    area doesn't exist, create it
-            if new_area_name not in bboxes:
-                bboxes[new_area_name] = {}
-
-            # Save the new bounding box under the date range key
-            bboxes[new_area_name] = {
-                "bounding_box": selected_area_geojson,
-                "date_ranges": [],  # Will be populated when files are downloaded
-            }
-            # Write the updated data back to file
-            with open("./bboxes/bboxes.json", "w") as f:
-                json.dump(bboxes, f, indent=4)
-
-            st.toast("Area successfully created")

app/pages/0_🌍_AOIs.py

@@ -0,0 +1,134 @@
+import folium
+import streamlit as st
+from folium.plugins import Draw
+from src.config_parameters import params
+from src.gfm import create_aoi, delete_aoi, retrieve_all_aois
+from src.utils import (
+    add_about,
+    get_aoi_id_from_selector_preview,
+    set_tool_page_style,
+    toggle_menu_button,
+)
+from streamlit_folium import st_folium
+
+# Page configuration
+st.set_page_config(layout="wide", page_title=params["browser_title"])
+
+# If app is deployed hide menu button
+toggle_menu_button()
+
+# Create sidebar
+add_about()
+
+# Page title
+st.markdown("# AOIs")
+
+# Set page style
+set_tool_page_style()
+
+row1 = st.container()
+save_area = False
+
+# To track whether radio selector was changed to reload AOIs if necessary, initialised as See Areas to prevent double loading
+if "prev_radio_selection" not in st.session_state:
+    st.session_state["prev_radio_selection"] = "See Areas"
+
+if "all_aois" not in st.session_state:
+    st.session_state["all_aois"] = retrieve_all_aois()
+
+
+feat_group_selected_area = folium.FeatureGroup(name="selected_area")
+radio_selection = st.radio(
+    label="Action Type",
+    options=["See Areas", "Create New Area", "Delete Area"],
+    label_visibility="hidden",
+)
+
+# call to render Folium map in Streamlit
+folium_map = folium.Map([39, 0], zoom_start=8)
+
+# See Areas will show all areas collected from GFM.
+# Collecting AOIs is done on first page load and when switching from a different radio selection back to See Areas
+if radio_selection == "See Areas":
+    if st.session_state["prev_radio_selection"] != "See Areas":
+        st.session_state["all_aois"] = retrieve_all_aois()
+
+    # Add each AOI as a feature group to the map
+    for aoi in st.session_state["all_aois"].values():
+        feat_group_selected_area.add_child(folium.GeoJson(aoi["bbox"]))
+
+    folium_map.fit_bounds(feat_group_selected_area.get_bounds())
+    st.session_state["prev_radio_selection"] = "See Areas"
+
+# When creating a new area the map will have a rectangle drawing option which will be saved with Save button
+elif radio_selection == "Create New Area":
+    Draw(
+        export=False,
+        draw_options={
+            "circle": False,
+            "polyline": False,
+            "polygon": False,
+            "rectangle": True,
+            "marker": False,
+            "circlemarker": False,
+        },
+    ).add_to(folium_map)
+
+    new_area_name = st.text_input("Area name")
+    save_area = st.button("Save Area")
+
+    st.session_state["prev_radio_selection"] = "Create New Area"
+
+# Delete area does exactly that, it will show the selected area and a delete button
+elif radio_selection == "Delete Area":
+    existing_areas = [
+        aoi["name_id_preview"] for aoi in st.session_state["all_aois"].values()
+    ]
+
+    area_to_delete_name_id = st.selectbox(
+        "Choose area to delete", options=existing_areas
+    )
+    selected_area_id = get_aoi_id_from_selector_preview(
+        st.session_state["all_aois"], area_to_delete_name_id
+    )
+
+    bbox = st.session_state["all_aois"][selected_area_id]["bbox"]
+    feat_group_selected_area.add_child(folium.GeoJson(bbox))
+    folium_map.fit_bounds(feat_group_selected_area.get_bounds())
+
+    delete_area = st.button("Delete")
+    st.session_state["prev_radio_selection"] = "Delete Area"
+
+    # If clicked will delete both from API and the session state to also remove from the Delete Area selector
+    if delete_area:
+        delete_aoi(selected_area_id)
+        st.session_state["all_aois"].pop(selected_area_id, None)
+        st.toast("Area successfully deleted")
+        st.rerun()
+
+# Create map with features based on the radio selector handling above
+m = st_folium(
+    folium_map,
+    width=800,
+    height=450,
+    feature_group_to_add=feat_group_selected_area,
+)
+
+# If in Create New Area the save button is clicked it will write the new area to the API
+if save_area:
+    check_drawing = m["all_drawings"] != [] and m["all_drawings"] is not None
+    if not check_drawing:
+        st.error("Please create a region using the rectangle tool on the map.")
+    elif new_area_name == "":
+        st.error("Please provide a name for the new area")
+    else:
+        # Get the drawn area
+        selected_area_geojson = m["all_drawings"][-1]
+
+        print("starting to post new area name to gfm api")
+        coordinates = selected_area_geojson["geometry"]["coordinates"]
+
+        create_aoi(new_area_name, coordinates)
+        st.toast("Area successfully created")
+
+st.session_state["prev_page"] = "aois"

app/pages/1_🌍_Flood_extent_analysis.py

@@ -1,130 +0,0 @@
-import json
-from pathlib import Path
-
-import folium
-import streamlit as st
-from folium.plugins import Draw
-from src.config_parameters import params
-from src.gfm import download_gfm_geojson, get_existing_flood_geojson, sync_cached_data
-from src.utils import (
-    add_about,
-    set_tool_page_style,
-    toggle_menu_button,
-)
-from streamlit_folium import st_folium
-
-# Page configuration
-st.set_page_config(layout="wide", page_title=params["browser_title"])
-
-# If app is deployed hide menu button
-toggle_menu_button()
-
-# Create sidebar
-add_about()
-
-# Page title
-st.markdown("# Flood extent analysis")
-
-# Set page style
-set_tool_page_style()
-
-# Sync cached data
-# ! WARNING: will erase your output folder
-# # # sync_cached_data()
-
-# Create two rows: top and bottom panel
-row1 = st.container()
-# Crate two columns in the top panel: input map and paramters
-col1, col2 = row1.columns([2, 1])
-feat_group_selected_area = folium.FeatureGroup(name="selected_area")
-with col1:
-    with open("./bboxes/bboxes.json", "r") as f:
-        bboxes = json.load(f)
-    selected_area = st.selectbox("Select saved area", options=bboxes.keys())
-
-    # retrieve and select available dates
-    if selected_area:
-        area_folder = Path(f"./output/{selected_area}")
-        if area_folder.exists():
-            available_product_times = [
-                str(f.name) for f in area_folder.iterdir() if f.is_dir()
-            ]
-
-            available_product_times = [
-                prod_time.replace("_", ":") for prod_time in available_product_times
-            ]
-            selected_product_time = st.selectbox(
-                "Select available date range", options=available_product_times
-            )
-        else:
-            selected_product_time = None
-
-        # display the bounding box
-        bounding_box = bboxes[selected_area]["bounding_box"]
-        geojson_selected_area = folium.GeoJson(bounding_box)
-        feat_group_selected_area.add_child(geojson_selected_area)
-
-        # geojson_selected_area = folium.GeoJson(bboxes[selected_area])
-        # feat_group_selected_area.add_child(geojson_selected_area)
-        if selected_product_time:
-            geojson_flood_area = get_existing_flood_geojson(
-                selected_area, selected_product_time
-            )
-            feat_group_selected_area.add_child(geojson_flood_area)
-
-    # Add collapsable container for input map
-    with st.expander("Input map", expanded=True):
-        # Create folium map
-        # call to render Folium map in Streamlit
-        folium_map = folium.Map([39, 0], zoom_start=8)
-        # check if the FeatureGroup has any children (i.e., layers added)
-        if len(feat_group_selected_area._children) > 0:
-            # if there is data, fit the map to the bounds
-            folium_map.fit_bounds(feat_group_selected_area.get_bounds())
-        else:
-            # if there is no data, set a default view
-            # this is necessary to start up the page
-            folium_map = folium.Map(location=[39, 0], zoom_start=8)
-
-        m = st_folium(
-            folium_map,
-            width=800,
-            height=450,
-            feature_group_to_add=feat_group_selected_area,
-        )
-with col2:
-    # Add collapsable container for image dates
-    with st.expander("Choose Dates", expanded=True):
-        start_date = st.date_input("Start date")
-        end_date = st.date_input("End date")
-    # Add collapsable container for parameters
-    with st.expander("Choose Parameters"):
-        # Add slider for threshold
-        st.text("Add relevant (API) parameters here")
-
-    submitted = st.button("Update flood extent")
-
-
-# If the button is clicked do the following
-if submitted:
-    with col2:
-        # Some basic validation on dates and that there's an area if relevant
-        get_gfm = True
-        check_dates = start_date <= end_date
-
-        # Output error if dates are not valid
-        if not check_dates:
-            st.error("Make sure that the dates were inserted correctly")
-            get_gfm = False
-
-        # Only if checks pass go and get the GFM data
-        if get_gfm:
-            # Show loader because it will take a while
-            with st.spinner("Getting GFM files... Please wait..."):
-                # download_gfm_geojson(area_name)
-                download_gfm_geojson(
-                    selected_area, from_date=start_date, to_date=end_date
-                )
-
-            # Display that getting the files is finished
-            st.markdown("Getting GFM files finished")

app/pages/1_💧_Flood_extent_analysis.py

@@ -0,0 +1,180 @@
+from datetime import date, timedelta
+
+import folium
+import pandas as pd
+import streamlit as st
+from src.config_parameters import params
+from src.gfm import (
+    download_flood_product,
+    get_area_products,
+    retrieve_all_aois,
+)
+from src.utils import (
+    add_about,
+    get_aoi_id_from_selector_preview,
+    get_existing_flood_geojson,
+    set_tool_page_style,
+    toggle_menu_button,
+)
+from streamlit_folium import st_folium
+
+today = date.today()
+
+default_date_yesterday = today - timedelta(days=1)
+
+# Page configuration
+st.set_page_config(layout="wide", page_title=params["browser_title"])
+
+# If app is deployed hide menu button
+toggle_menu_button()
+
+# Create sidebar
+add_about()
+
+# Page title
+st.markdown("# Flood extent analysis")
+
+# Set page style
+set_tool_page_style()
+
+# Create two rows: top and bottom panel
+row1 = st.container()
+row2 = st.container()
+# Crate two columns in the top panel: input map and paramters
+col1, col2, col3, col4, col5 = row1.columns([1, 1, 1, 1, 1])
+col2_1, col2_2 = row2.columns([3, 2])
+
+# Retrieve AOIs to fill AOI selector
+if "all_aois" not in st.session_state:
+    st.session_state["all_aois"] = retrieve_all_aois()
+
+# If coming from a different page, all aois may be filled but not up to date, retrigger
+if st.session_state["prev_page"] != "flood_extent":
+    st.session_state["all_aois"] = retrieve_all_aois()
+
+if "all_products" not in st.session_state:
+    st.session_state["all_products"] = None
+
+
+# To force removing product checkboxes when AOI selector changes
+def on_area_selector_change():
+    print("Area selector changed, removing product checkboxes")
+    st.session_state["all_products"] = None
+
+
+# Contains AOI selector
+with col1:
+    selected_area_name_id = st.selectbox(
+        "Select saved AOI",
+        options=[
+            aoi["name_id_preview"] for aoi in st.session_state["all_aois"].values()
+        ],
+        on_change=on_area_selector_change,
+    )
+
+    selected_area_id = get_aoi_id_from_selector_preview(
+        st.session_state["all_aois"], selected_area_name_id
+    )
+
+# Contain datepickers
+with col2:
+    today = date.today()
+    two_weeks_ago = today - timedelta(days=14)
+    start_date = st.date_input("Start date", value=two_weeks_ago)
+
+with col3:
+    end_date = st.date_input("End date", value=today)
+
+# Contains available products button
+with col4:
+    st.text(
+        "Button info",
+        help="""
+    This will show the timestamps of all available GFM products
+    that intersect with the AOI for the selected date range.
+    Getting the available products is a relatively fast operation
+    it will not trigger any product downloads.
+    """,
+    )
+    show_available_products = st.button("Show available products")
+
+# If button above is triggered, get products from GFM
+# Then save all products to the session state and rerun the app to display them
+if show_available_products:
+    products = get_area_products(selected_area_id, start_date, end_date)
+    st.session_state["all_products"] = products
+    st.rerun()
+
+# Contains the product checkboxes if they exist after pushing the "Show available products" button
+with col2_2:
+    checkboxes = list()
+    # Products are checked against the index to check whether they are already downloaded
+    index_df = pd.read_csv("./output/index.csv")
+    if st.session_state["all_products"]:
+        for product in st.session_state["all_products"]:
+            suffix = ""
+            if product["product_id"] in index_df["product"].values:
+                suffix = " - Already Downloaded"
+            checkbox = st.checkbox(product["product_time"] + suffix)
+            checkboxes.append(checkbox)
+
+# Contains the "Download Products" button
+with col5:
+    st.text(
+        "Button info",
+        help=""
+        """
+    Will download the selected products (click "Show available products"
+    first if there are none). Products that show that they have already
+    been downloaded can be left checked, they will be skipped.
+    """,
+    )
+    download_products = st.button("Download products")
+
+    # If the button is clicked download all checked products that have not been downloaded yet
+    if download_products:
+        index_df = pd.read_csv("./output/index.csv")
+        for i, checkbox in enumerate(checkboxes):
+            if checkbox:
+                product_to_download = st.session_state["all_products"][i]
+                if product_to_download["product_id"] not in index_df["product"].values:
+                    with st.spinner(
+                        f"Getting GFM files for {product_to_download['product_time']}, this may take a couple of minutes"
+                    ):
+                        download_flood_product(selected_area_id, product_to_download)
+        st.rerun()
+
+# For all the selected products add them to the map if they are available
+feature_groups = []
+if st.session_state["all_products"]:
+    index_df = pd.read_csv("./output/index.csv")
+    for i, checkbox in enumerate(checkboxes):
+        if checkbox:
+            product_id = st.session_state["all_products"][i]["product_id"]
+            if product_id in index_df["product"].values:
+                feat_group_flood = get_existing_flood_geojson(product_id)
+                feature_groups.append(feat_group_flood)
+
+# Contains the map
+with col2_1:
+    if selected_area_id:
+        # display the bounding box
+        bounding_box = st.session_state["all_aois"][selected_area_id]["bbox"]
+        geojson_selected_area = folium.GeoJson(bounding_box)
+        feat_group_selected_area = folium.FeatureGroup(name="selected_area")
+        feat_group_selected_area.add_child(geojson_selected_area)
+        feature_groups.append(feat_group_selected_area)
+
+    # Create folium map
+    folium_map = folium.Map([39, 0], zoom_start=8)
+    folium_map.fit_bounds(feat_group_selected_area.get_bounds())
+
+    m = st_folium(
+        folium_map,
+        width=800,
+        height=450,
+        feature_group_to_add=feature_groups,
+    )
+
+# Keep track of which page we're currently on for page switch events
+st.session_state["prev_page"] = "flood_extent"

app/pages/2_📖_Documentation.py

@@ -1,4 +1,4 @@
-"""Documentation page for Streamlit app."""
+# """Documentation page for Streamlit app."""
 
 import streamlit as st
 from src.config_parameters import params

app/src/gfm.py

@@ -1,62 +1,18 @@
 import io
-import json
 import os
 import zipfile
 from pathlib import Path
 
-import folium
+import pandas as pd
 import requests
 from dotenv import load_dotenv
 
 load_dotenv()
 
 
-class FloodGeoJsonError(Exception):
-    """Custom exception for errors in fetching flood GeoJSON files."""
-
-    pass
-
-
-def sync_cached_data(bboxes_path="./bboxes/bboxes.json", output_dir="./output"):
-    """
-    Ensures that all areas in bboxes.json have a corresponding folder in ./output/.
-    Removes any area entry from bboxes.json that does not have an output folder.
-    """
-    try:
-        # Load existing bounding boxes
-        with open(bboxes_path, "r") as f:
-            bboxes = json.load(f)
-
-        # Get a set of existing output folders
-        existing_folders = {
-            folder.name for folder in Path(output_dir).iterdir() if folder.is_dir()
-        }
-
-        # Remove entries from bboxes.json if the folder does not exist
-        updated_bboxes = {
-            area: data for area, data in bboxes.items() if area in existing_folders
-        }
-
-        # If changes were made, overwrite bboxes.json
-        if len(updated_bboxes) != len(bboxes):
-            with open(bboxes_path, "w") as f:
-                json.dump(updated_bboxes, f, indent=4)
-            print(f"Updated {bboxes_path}: Removed missing areas.")
-        else:
-            print("All areas have matching folders.")
-
-    except FileNotFoundError:
-        print(f"Error: {bboxes_path} not found.")
-    except json.JSONDecodeError:
-        print(f"Error: {bboxes_path} is not a valid JSON file.")
-
-
-def download_gfm_geojson(
-    area_name, from_date=None, to_date=None, output_file_path=None
-):
-    """
-    Should provide an existing area name or a new area name with new_coordinates
-    """
+# TODO: These functions should be transformed into a proper class mainly to prevent authentication on each call
+# Authentication
+def get_gfm_user_and_token():
     username = os.environ["gfm_username"]
     password = os.environ["gfm_password"]
     base_url = "https://api.gfm.eodc.eu/v1"
@@ -69,76 +25,142 @@ def download_gfm_geojson(
     response = requests.post(token_url, json=payload)
     user_id = response.json()["client_id"]
     access_token = response.json()["access_token"]
-    header = {"Authorization": f"bearer {access_token}"}
-    print("logged in")
+    print("retrieved user id and access token")
+
+    return user_id, access_token
 
-    # Get Area of Impact
-    aoi_url = f"{base_url}/aoi/user/{user_id}"
-    response = requests.get(aoi_url, headers=header)
 
-    # TODO: now only getting the first AOI, should extend to getting the whole list and unioning the geojsons
-    for aoi in response.json()["aois"]:
-        if aoi["aoi_name"] == area_name:
-            aoi_id = aoi["aoi_id"]
-            break
+# Gets all products for an AOI in a daterange
+def get_area_products(area_id, from_date, to_date):
+    user_id, access_token = get_gfm_user_and_token()
+    header = {"Authorization": f"bearer {access_token}"}
+
+    base_url = "https://api.gfm.eodc.eu/v1"
 
-    # Get all product IDs
     params = {
         "time": "range",
         "from": f"{from_date}T00:00:00",
         "to": f"{to_date}T00:00:00",
     }
-    prod_url = f"{base_url}/aoi/{aoi_id}/products"
+    prod_url = f"{base_url}/aoi/{area_id}/products"
     response = requests.get(prod_url, headers=header, params=params)
     products = response.json()["products"]
-    print(f"Found {len(products)} products for {area_name}")
+    print(f"Found {len(products)} products for {area_id}")
+
+    return products
+
+
+# Will download a product by product_id, saves the flood geojson and updates the index for caching
+def download_flood_product(area_id, product, output_file_path=None):
+    user_id, access_token = get_gfm_user_and_token()
+    header = {"Authorization": f"bearer {access_token}"}
+
+    base_url = "https://api.gfm.eodc.eu/v1"
 
     if not output_file_path:
         base_file_path = "./output"
 
-    # Download all available flood products
-    for product in products:
-        product_id = product["product_id"]
+    product_id = product["product_id"]
+    product_time = product["product_time"]
+
+    output_file_path = f"{base_file_path}"
+    Path(output_file_path).mkdir(parents=True, exist_ok=True)
 
-        # Converts product_time from e.g. "2025-01-05T06:10:37" to ""2025-01-05 06h
-        # Reason for bucketing per hour is that products are often seconds or minutes apart and should be grouped
-        product_time = product["product_time"]
-        product_time = product_time.split(":")[0].replace("T", " ") + "h"
-        output_file_path = f"{base_file_path}/{area_name}/{product_time}"
-        Path(output_file_path).mkdir(parents=True, exist_ok=True)
+    print(f"Downloading product: {product_id}")
 
-        print(f"Downloading product: {product_id}")
+    download_url = f"{base_url}/download/product/{product_id}"
+    response = requests.get(download_url, headers=header)
+    download_link = response.json()["download_link"]
 
-        download_url = f"{base_url}/download/product/{product_id}"
-        response = requests.get(download_url, headers=header)
-        download_link = response.json()["download_link"]
+    # Download and unzip file
+    r = requests.get(download_link)
+    buffer = io.BytesIO(r.content)
 
-        # Download and unzip file
-        r = requests.get(download_link)
-        with zipfile.ZipFile(io.BytesIO(r.content)) as z:
-            print("Extracting...")
-            z.extractall(str(Path(output_file_path)))
+    with zipfile.ZipFile(buffer, "r") as z:
+        namelist = z.namelist()
+        for name in namelist:
+            if "FLOOD" in name and ".geojson" in name:
+                flood_filename = name
+                break
+        z.extract(flood_filename, output_file_path)
 
-    print("Done!")
+    df = pd.DataFrame(
+        {
+            "aoi_id": [area_id],
+            "datetime": [product_time],
+            "product": [product_id],
+            "geojson_path": [output_file_path + "/" + flood_filename],
+        }
+    )
 
+    index_file_path = Path(f"{output_file_path}/index.csv")
+    if index_file_path.is_file():
+        existing_df = pd.read_csv(index_file_path)
+        df = pd.concat([existing_df, df])
 
-def get_existing_flood_geojson(area_name, product_time, output_file_path=None):
-    """
-    Getting a saved GFM flood geojson in an output folder of GFM files. Merge in one feature group if multiple.
-    """
-    product_time = product_time.replace(":", "_")
-    if not output_file_path:
-        output_file_path = f"./output/{area_name}/{product_time}"
+    df.to_csv(index_file_path, index=False)
+
+    print(f"Product {product_id} downloaded succesfully")
 
-    # Combine multiple flood files into a FeatureGroup
-    flood_geojson_group = folium.FeatureGroup(name=f"{area_name} Floods {product_time}")
 
-    for flood_file in Path(output_file_path).glob("*FLOOD*.geojson"):
-        with open(flood_file, "r") as f:
-            geojson_data = json.load(f)
-            flood_layer = folium.GeoJson(geojson_data)
-            flood_geojson_group.add_child(flood_layer)
+# Gets all AOIs and transforms them to a dict with some features that are useful in the app, like the bbox
+def retrieve_all_aois():
+    print("Retrieving all AOIs from GFM API")
+    user_id, access_token = get_gfm_user_and_token()
+    header = {"Authorization": f"bearer {access_token}"}
+
+    base_url = "https://api.gfm.eodc.eu/v1"
+
+    aoi_url = f"{base_url}/aoi/user/{user_id}"
+    response = requests.get(aoi_url, headers=header)
+
+    aois = response.json()["aois"]
+
+    aois = {
+        aoi["aoi_id"]: {
+            "name": aoi["aoi_name"],
+            "bbox": aoi["geoJSON"],
+            "name_id_preview": f"{aoi['aoi_name']} - {aoi['aoi_id'][:6]}...",
+        }
+        for aoi in aois
+    }
+
+    return aois
+
+
+# Creates AOI on GFM using API
+def create_aoi(new_area_name, coordinates):
+    user_id, access_token = get_gfm_user_and_token()
+    header = {"Authorization": f"bearer {access_token}"}
+
+    base_url = "https://api.gfm.eodc.eu/v1"
+
+    # Create area of impact
+    print("Creating new area of impact")
+    create_aoi_url = f"{base_url}/aoi/create"
+
+    payload = {
+        "aoi_name": new_area_name,
+        "description": new_area_name,
+        "user_id": user_id,
+        "geoJSON": {"type": "Polygon", "coordinates": coordinates},
+    }
+
+    r = requests.post(url=create_aoi_url, json=payload, headers=header)
+    print("Posted new AOI")
+
+
+# Deletes AOI on GFM using API
+def delete_aoi(aoi_id):
+    user_id, access_token = get_gfm_user_and_token()
+    header = {"Authorization": f"bearer {access_token}"}
+
+    base_url = "https://api.gfm.eodc.eu/v1"
 
-    # TODO: consider merging multiple flood layers into one, to avoid overlap
+    # Create area of impact
+    print(f"Deleting area of impact {aoi_id}")
+    delete_aoi_url = f"{base_url}/aoi/delete/id/{aoi_id}"
+    print(delete_aoi_url)
 
-    return flood_geojson_group
+    r = requests.delete(url=delete_aoi_url, headers=header)
+    print("AOI deleted")

app/src/utils.py

@@ -1,14 +1,21 @@
 """Functions for the layout of the Streamlit app, including the sidebar."""
 
-import base64
+import json
 import os
-from datetime import date
 
+import folium
+import pandas as pd
 import streamlit as st
 
 from src.config_parameters import params
 
 
+def get_aoi_id_from_selector_preview(all_aois, name_id_preview):
+    for aoi_id, aoi in all_aois.items():
+        if aoi["name_id_preview"] == name_id_preview:
+            return aoi_id
+
+
 # Check if app is deployed
 def is_app_on_streamlit():
     """Check whether the app is on streamlit or runs locally."""
@@ -148,3 +155,21 @@ def add_about():
         % (params["about_box_background_color"], contacts_text),
         unsafe_allow_html=True,
     )
+
+
+def get_existing_flood_geojson(product_id, output_file_path="./output/"):
+    """
+    Getting a saved GFM flood geojson in an output folder of GFM files. Merge in one feature group if multiple.
+    """
+    index_df = pd.read_csv(output_file_path + "index.csv")
+    geojson_path = index_df[index_df["product"] == product_id].geojson_path.values[0]
+
+    # Combine multiple flood files into a FeatureGroup
+    flood_geojson_group = folium.FeatureGroup(name=product_id)
+
+    with open(geojson_path, "r") as f:
+        geojson_data = json.load(f)
+        flood_layer = folium.GeoJson(geojson_data)
+        flood_geojson_group.add_child(flood_layer)
+
+    return flood_geojson_group

pyproject.toml

@@ -11,5 +11,5 @@ dependencies = [
     "python-dotenv==1.0.1",
     "streamlit>=1.41.1",
     "streamlit-folium>=0.24.0",
-    "ipykernel>=6.29.5",
+    "ipykernel>=6.29.5"
 ]