Merge pull request #110 from hotosm/add/new-ui

Add/new UI

Author: warmijusti

backend/app/api/routes/chatmap/chatmap.py

@@ -1,38 +1,39 @@
+import logging
 import httpx
 from fastapi import APIRouter, HTTPException, Request
 from hotosm_auth_fastapi import CurrentUser
 from app.core.config import settings
 
+logger = logging.getLogger(__name__)
+
 CHATMAP_API_BASE_URL = settings.chatmap_api_base_url
 
 router = APIRouter(prefix="/chatmap")
 
 
-@router.get("/map")
-async def get_my_chatmap(
+@router.get("/user/maps")
+async def get_user_chatmaps(
     request: Request,
     user: CurrentUser,
 ) -> dict:
     """
-    Get the authenticated user's ChatMap (GeoJSON FeatureCollection).
+    Get the authenticated user's ChatMap maps.
 
-    Forwards the Hanko auth cookie to the ChatMap API, which returns
-    the map belonging to the authenticated user.
+    Calls ChatMap API using the Hanko user ID and returns the list of maps.
     """
     hanko_cookie = request.cookies.get("hanko")
     if not hanko_cookie:
-        raise HTTPException(status_code=401, detail="Hanko auth cookie not found")
+        raise HTTPException(status_code=401, detail="Hanko authentication cookie not found.")
 
-    url = f"{CHATMAP_API_BASE_URL}/map"
+    url = f"{CHATMAP_API_BASE_URL}/user/{user.id}/map"
 
     async with httpx.AsyncClient(timeout=30.0, verify=False) as client:
         try:
-            response = await client.get(
-                url,
-                cookies={"hanko": hanko_cookie},
-            )
+            response = await client.get(url, cookies={"hanko": hanko_cookie})
             response.raise_for_status()
-            return response.json()
+            maps = response.json()
+            logger.info("[ChatMap] Found %d maps for user %s", len(maps), user.id)
+            return {"maps": maps}
         except httpx.HTTPStatusError as e:
             raise HTTPException(
                 status_code=e.response.status_code,

backend/app/api/routes/umap/umap.py

@@ -6,204 +6,56 @@
 import re
 import logging
 import httpx
-from bs4 import BeautifulSoup
 from fastapi import APIRouter, HTTPException, Path, Request
 from app.models.umap import (
     UMapFeatureCollection,
     ShowcaseResponse,
     UserMapsResponse,
-    UserTemplatesResponse,
 )
 from app.core.cache import get_cached, set_cached, DEFAULT_TTL
 from app.core.config import settings
 
-# Setup logging
 logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/umap")
 
-# uMap HOT OSM URLs derived from settings
 UMAP_BASE_URL = settings.umap_base_url
-UMAP_LOCALE = settings.umap_locale
 UMAP_API_BASE_URL = f"{UMAP_BASE_URL}/en/datalayer"
 UMAP_SHOWCASE_URL = f"{UMAP_BASE_URL}/en/showcase/"
-
-# SSL verification: disabled by default for .test domains (self-signed certs)
-# Set UMAP_VERIFY_SSL=true in production with valid certificates
 UMAP_VERIFY_SSL = os.getenv("UMAP_VERIFY_SSL", "false").lower() == "true"
 
-# Matches /es/map/slug_123 or /map/slug_123 (any locale prefix or none)
-_MAP_HREF_RE = re.compile(r"^/(?:[a-z]{2}/)?map/(.+)$")
-
-logger.info(f"uMap Base URL: {UMAP_BASE_URL}")
-logger.info(f"uMap Locale: {UMAP_LOCALE}")
-logger.info(f"uMap SSL Verification: {UMAP_VERIFY_SSL}")
-
-
-def _parse_map_links(html: str) -> list[dict]:
-    """Extract unique map entries from an HTML page using BeautifulSoup.
-
-    Returns a list of dicts with keys: id, slug, href, url.
-    Skips ?share / ?edit variants and deduplicates by map ID.
-    """
-    soup = BeautifulSoup(html, "html.parser")
-    results = []
-    seen: set[str] = set()
-
-    for a in soup.find_all("a", href=True):
-        href: str = a["href"]
-        if "?share" in href or "?edit" in href:
-            continue
-        match = _MAP_HREF_RE.match(href)
-        if not match:
-            continue
-        slug = match.group(1)
-        parts = slug.rsplit("_", 1)
-        map_id = parts[-1] if len(parts) > 1 and parts[-1].isdigit() else slug
-        if map_id in seen:
-            continue
-        seen.add(map_id)
-        results.append(
-            {"id": map_id, "slug": slug, "href": href, "url": f"{UMAP_BASE_URL}{href}"}
-        )
-
-    return results
-
-
-def _check_login_redirect(response: httpx.Response, html: str) -> bool:
-    """Return True if uMap redirected to the login page (auth failed)."""
-    return "/login" in str(response.url) or "Iniciar sesión" in html
-
-
-@router.get("/user/templates", response_model=UserTemplatesResponse)
-async def get_user_templates(request: Request) -> dict:
-    """Fetch the user's templates page from uMap and return a JSON list.
-
-    Uses Hanko authentication cookie to authenticate with the uMap instance.
-    Returns JSON with an array under `templates` containing objects with
-    `id`, `href`, `url` and `slug` keys.
-    """
-    hanko_cookie = request.cookies.get("hanko")
-    logger.info(f"[Templates] Hanko cookie present: {bool(hanko_cookie)}")
-
-    if not hanko_cookie:
-        logger.warning("No Hanko cookie found in request")
-        raise HTTPException(
-            status_code=401,
-            detail="Hanko authentication cookie not found. Please log in.",
-        )
-
-    url = f"{UMAP_BASE_URL}/{UMAP_LOCALE}/me/templates"
-    logger.info(f"[Templates] Target URL: {url}")
-
-    try:
-        async with httpx.AsyncClient(
-            timeout=30.0,
-            verify=UMAP_VERIFY_SSL,
-            follow_redirects=True,
-        ) as client:
-            response = await client.get(
-                url,
-                headers={"User-Agent": "portal-umap-client/1.0"},
-                cookies={"hanko": hanko_cookie},
-            )
-            response.raise_for_status()
-            html = response.text
 
-            logger.info(f"[Templates] Final URL: {response.url}")
-            logger.info(f"[Templates] Response length: {len(html)} chars")
-            logger.debug(f"[Templates] HTML preview: {html[:500]}")
+def _umap_client() -> httpx.AsyncClient:
+    return httpx.AsyncClient(timeout=30.0, verify=UMAP_VERIFY_SSL, follow_redirects=True)
 
-            if _check_login_redirect(response, html):
-                logger.warning("[Templates] Auth failed - redirected to login page")
-                raise HTTPException(
-                    status_code=401,
-                    detail="uMap authentication failed. Your session may have expired.",
-                )
 
-            templates = _parse_map_links(html)
-            logger.info(f"[Templates] Found {len(templates)} templates")
-            return {"templates": templates}
+def _require_hanko(request: Request) -> str:
+    cookie = request.cookies.get("hanko")
+    if not cookie:
+        raise HTTPException(status_code=401, detail="Hanko authentication cookie not found.")
+    return cookie
 
-    except httpx.HTTPStatusError as e:
-        logger.error(f"HTTP Error: {e.response.status_code} - {e.response.text}")
-        raise HTTPException(
-            status_code=e.response.status_code,
-            detail=f"Error fetching uMap templates: {e.response.text}",
-        )
-    except httpx.RequestError as e:
-        logger.error(f"Request Error: {str(e)}")
-        raise HTTPException(status_code=503, detail=f"Connection error to uMap: {str(e)}")
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Unexpected error: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
 
 
 @router.get("/user/maps", response_model=UserMapsResponse)
 async def get_user_maps(request: Request) -> dict:
-    """Fetch the user's maps page from uMap and return a JSON list.
-
-    Uses Hanko authentication cookie to authenticate with the uMap instance.
-    Returns JSON with an array under `maps` containing objects with
-    `id`, `slug`, `href` and `url` keys.
-    """
-    hanko_cookie = request.cookies.get("hanko")
-    logger.info(f"[Maps] Hanko cookie present: {bool(hanko_cookie)}")
-
-    if not hanko_cookie:
-        logger.warning("No Hanko cookie found in request")
-        raise HTTPException(
-            status_code=401,
-            detail="Hanko authentication cookie not found. Please log in.",
-        )
-
-    url = f"{UMAP_BASE_URL}/{UMAP_LOCALE}/me"
-    logger.info(f"[Maps] Target URL: {url}")
+    """Fetch the authenticated user's maps from uMap."""
+    hanko_cookie = _require_hanko(request)
+    url = f"{UMAP_BASE_URL}/api/v1/maps/?source=mine"
 
     try:
-        async with httpx.AsyncClient(
-            timeout=30.0,
-            verify=UMAP_VERIFY_SSL,
-            follow_redirects=True,
-        ) as client:
-            response = await client.get(
-                url,
-                headers={"User-Agent": "portal-umap-client/1.0"},
-                cookies={"hanko": hanko_cookie},
-            )
+        async with _umap_client() as client:
+            response = await client.get(url, cookies={"hanko": hanko_cookie})
+            if response.status_code == 401:
+                raise HTTPException(status_code=401, detail="uMap authentication failed.")
             response.raise_for_status()
-            html = response.text
-
-            logger.info(f"[Maps] Final URL: {response.url}")
-            logger.info(f"[Maps] Response length: {len(html)} chars")
-
-            if _check_login_redirect(response, html):
-                logger.warning("[Maps] Auth failed - redirected to login page")
-                raise HTTPException(
-                    status_code=401,
-                    detail="uMap authentication failed. Your session may have expired.",
-                )
-
-            maps = _parse_map_links(html)
-            logger.info(f"[Maps] Found {len(maps)} maps")
-            return {"maps": maps}
-
+            data = response.json()
+            logger.info(f"[Maps] Found {len(data.get('maps', []))} maps")
+            return data
     except httpx.HTTPStatusError as e:
-        logger.error(f"HTTP Error: {e.response.status_code} - {e.response.text}")
-        raise HTTPException(
-            status_code=e.response.status_code,
-            detail=f"Error fetching uMap maps: {e.response.text}",
-        )
+        raise HTTPException(status_code=e.response.status_code, detail=f"uMap error: {e.response.text}")
     except httpx.RequestError as e:
-        logger.error(f"Request Error: {str(e)}")
         raise HTTPException(status_code=503, detail=f"Connection error to uMap: {str(e)}")
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Unexpected error: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
 
 
 @router.get("/showcase", response_model=ShowcaseResponse)

backend/app/models/umap.py

@@ -103,12 +103,14 @@ class ShowcaseResponse(BaseModel):
 
 
 class UserMap(BaseModel):
-    """A single map entry from the user's maps page."""
+    """A single map entry from the user's maps."""
 
-    id: str
+    id: int
+    name: str
+    description: Optional[str] = None
     slug: str
-    href: str
     url: str
+    modified_at: str
 
 
 class UserMapsResponse(BaseModel):
@@ -117,16 +119,3 @@ class UserMapsResponse(BaseModel):
     maps: List[UserMap]
 
 
-class UserTemplate(BaseModel):
-    """A single template entry from the user's templates page."""
-
-    id: str
-    slug: str
-    href: str
-    url: str
-
-
-class UserTemplatesResponse(BaseModel):
-    """Response for the /umap/user/templates endpoint."""
-
-    templates: List[UserTemplate]

frontend/src/assets/images/imagery-portal.png

@@ -1,17 +1,69 @@
 import hotLogo from "../assets/images/hot-logo.svg";
+
+const categories = [
+  {
+    name: "Imagery",
+    tools: ["Drone Tasking Manager", "OpenAerialMap"],
+  },
+  {
+    name: "Mapping",
+    tools: ["Tasking Manager", "fAIr"],
+  },
+  {
+    name: "Field",
+    tools: ["Field Tasking Manager", "ChatMap"],
+  },
+  {
+    name: "Data",
+    tools: ["Export Tool", "uMap"],
+  },
+];
+
 function Footer() {
   return (
-    <footer className="bg-hot-gray-50">
-      <div className="container flex flex-col sm:flex-row justify-between items-center py-lg gap-md">
-        <img
-          src={hotLogo}
-          alt="HOT Logo"
-          className="h-[34px] w-[178px] grayscale"
-        />
-        <span className="text-xs text-end">
-          Humanitarian OpenStreetMap Team is a 501(c)(3)
-          <br /> not-for-profit organization and global community.
-        </span>
+    <footer>
+      <div className="bg-hot-gray-50 py-3xl">
+        <div className="container grid grid-cols-2 sm:grid-cols-4 gap-2xl">
+          {categories.map((category) => (
+            <div key={category.name}>
+              <p
+                className="text-xl font-bold mb-md leading-tight"
+                style={{ fontFamily: "Barlow, sans-serif" }}
+              >
+                {category.name}
+              </p>
+              <ul className="list-none p-0 m-0 flex flex-col gap-xs">
+                {category.tools.map((tool) => (
+                  <li key={tool}>
+                    <span
+                      className="text-lg text-hot-gray-1000"
+                      style={{ fontFamily: "'Barlow Narrow', sans-serif" }}
+                    >
+                      {tool}
+                    </span>
+                  </li>
+                ))}
+              </ul>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      <div className="bg-hot-gray-950 py-xl">
+        <div className="container flex justify-between items-center gap-md">
+          <img
+            src={hotLogo}
+            alt="HOT Logo"
+            className="h-[34px] brightness-0 invert"
+          />
+          <p
+            className="text-sm text-hot-gray-100 text-right m-0 max-w-sm"
+            style={{ fontFamily: "Archivo, sans-serif" }}
+          >
+            This is free and open source software, brought to you by the
+            Humanitarian OpenStreetMap Team &amp; friends
+          </p>
+        </div>
       </div>
     </footer>
   );