PropertyFlow: Flex Technical Assessment

.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+
+# Node
+node_modules/
+
+# Env
+.env.local
+.env.*.local
+
+# OS / editor
+.DS_Store
+*.log
+vite.config.ts.timestamp-*.mjs
+
+# Build output
+frontend/dist/
+
+# Local env (see frontend/.env.example)
+.env

backend/app/api/v1/dashboard.py

@@ -1,25 +1,59 @@
-from fastapi import APIRouter, Depends, HTTPException
-from typing import Dict, Any
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Dict, Any, List, Optional
 from app.services.cache import get_revenue_summary
 from app.core.auth import authenticate_request as get_current_user
 
 router = APIRouter()
 
+
+def _require_tenant(current_user) -> str:
+    tenant_id = getattr(current_user, "tenant_id", None)
+    if not tenant_id:
+        raise HTTPException(status_code=403, detail="User is not assigned to a tenant")
+    return tenant_id
+
+
+@router.get("/dashboard/properties")
+async def get_dashboard_properties(current_user: dict = Depends(get_current_user)) -> List[Dict[str, str]]:
+    tenant_id = _require_tenant(current_user)
+
+    from app.core.database_pool import db_pool
+    from sqlalchemy import text
+
+    try:
+        await db_pool.initialize()
+        async with db_pool.get_session() as session:
+            result = await session.execute(
+                text("SELECT id, name FROM properties WHERE tenant_id = :tenant_id ORDER BY id"),
+                {"tenant_id": tenant_id},
+            )
+            return [{"id": row.id, "name": row.name} for row in result]
+    except Exception:
+        raise HTTPException(status_code=503, detail="Properties are temporarily unavailable")
+
+
 @router.get("/dashboard/summary")
 async def get_dashboard_summary(
     property_id: str,
+    month: Optional[int] = Query(None, ge=1, le=12),
+    year: Optional[int] = Query(None, ge=2000, le=2100),
     current_user: dict = Depends(get_current_user)
 ) -> Dict[str, Any]:
 
-    tenant_id = getattr(current_user, "tenant_id", "default_tenant") or "default_tenant"
-
-    revenue_data = await get_revenue_summary(property_id, tenant_id)
-
-    total_revenue_float = float(revenue_data['total'])
+    tenant_id = _require_tenant(current_user)
+
+    if (month is None) != (year is None):
+        raise HTTPException(status_code=400, detail="month and year must be provided together")
+
+    try:
+        revenue_data = await get_revenue_summary(property_id, tenant_id, month, year)
+    except Exception:
+        raise HTTPException(status_code=503, detail="Revenue data is temporarily unavailable")
 
     return {
         "property_id": revenue_data['property_id'],
-        "total_revenue": total_revenue_float,
+        # Sent as a decimal string; floats lose cents.
+        "total_revenue": revenue_data['total'],
         "currency": revenue_data['currency'],
         "reservations_count": revenue_data['count']
     }

backend/app/core/database_pool.py

@@ -1,6 +1,5 @@
 import asyncio
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-from sqlalchemy.pool import QueuePool
 import logging
 from ..config import settings
 
@@ -13,13 +12,15 @@ def __init__(self):
 
     async def initialize(self):
         """Initialize database connection pool"""
+        if self.session_factory:
+            return
+
         try:
-            # Create async engine with connection pooling
-            database_url = f"postgresql+asyncpg://{settings.supabase_db_user}:{settings.supabase_db_password}@{settings.supabase_db_host}:{settings.supabase_db_port}/{settings.supabase_db_name}"
-            
+            # Async engine needs the asyncpg driver in the URL.
+            database_url = settings.database_url.replace("postgresql://", "postgresql+asyncpg://", 1)
+
             self.engine = create_async_engine(
                 database_url,
-                poolclass=QueuePool,
                 pool_size=20,  # Number of connections to maintain
                 max_overflow=30,  # Additional connections when needed
                 pool_pre_ping=True,  # Validate connections
@@ -45,7 +46,7 @@ async def close(self):
         if self.engine:
             await self.engine.dispose()
 
-    async def get_session(self) -> AsyncSession:
+    def get_session(self) -> AsyncSession:
         """Get database session from pool"""
         if not self.session_factory:
             raise Exception("Database pool not initialized")

backend/app/core/tenant_resolver.py

@@ -69,7 +69,7 @@ def resolve_tenant_from_user(user_data: dict) -> Optional[str]:
         return None
 
     @staticmethod
-    async def resolve_tenant_id(user_id: str, user_email: str, token: Optional[str] = None) -> str:
+    async def resolve_tenant_id(user_id: str, user_email: str, token: Optional[str] = None) -> Optional[str]:
         """
         Resolve tenant ID for a user.
 
@@ -87,9 +87,35 @@ async def resolve_tenant_id(user_id: str, user_email: str, token: Optional[str]
             return "tenant-b"
         if user_email == "candidate@propertyflow.com":
             return "tenant-a"
+
+        # Extract tenant from token claims if provided
+        if token:
+            payload = None
+            try:
+                from jose import jwt
+                payload = jwt.get_unverified_claims(token)
+            except Exception:
+                try:
+                    import base64
+                    import json
+                    parts = token.split(".")
+                    if len(parts) >= 2:
+                        payload_b64 = parts[1]
+                        padding = len(payload_b64) % 4
+                        if padding:
+                            payload_b64 += "=" * (4 - padding)
+                        payload = json.loads(base64.urlsafe_b64decode(payload_b64).decode("utf-8"))
+                except Exception:
+                    payload = None
+
+            if payload and isinstance(payload, dict):
+                tenant_id = TenantResolver.resolve_tenant_from_token(payload)
+                if tenant_id:
+                    return tenant_id
 
-        # Default fallback
-        return "tenant-a"
+        # Unknown users get no tenant rather than another company's data.
+        logger.warning(f"No tenant mapping for {user_email}")
+        return None
 
     @staticmethod
     async def update_user_tenant_metadata(user_id: str, tenant_id: str) -> None:

backend/app/services/cache.py

@@ -1,27 +1,34 @@
 import json
 import redis.asyncio as redis
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 import os
 
 # Initialize Redis client (typically configured centrally).
 redis_client = redis.Redis.from_url(os.getenv("REDIS_URL", "redis://localhost:6379/0"))
 
-async def get_revenue_summary(property_id: str, tenant_id: str) -> Dict[str, Any]:
+async def get_revenue_summary(
+    property_id: str, tenant_id: str, month: Optional[int] = None, year: Optional[int] = None
+) -> Dict[str, Any]:
     """
     Fetches revenue summary, utilizing caching to improve performance.
     """
-    cache_key = f"revenue:{property_id}"
+    # Property IDs are only unique per tenant, so the key must include the tenant.
+    cache_key = f"revenue:{tenant_id}:{property_id}"
+    if month and year:
+        cache_key += f":{year}-{month:02d}"
 
     # Try to get from cache
     cached = await redis_client.get(cache_key)
     if cached:
         return json.loads(cached)
 
     # Revenue calculation is delegated to the reservation service.
-    from app.services.reservations import calculate_total_revenue
-
-    # Calculate revenue
-    result = await calculate_total_revenue(property_id, tenant_id)
+    from app.services.reservations import calculate_monthly_revenue, calculate_total_revenue
+
+    if month and year:
+        result = await calculate_monthly_revenue(property_id, tenant_id, month, year)
+    else:
+        result = await calculate_total_revenue(property_id, tenant_id)
 
     # Cache the result for 5 minutes
     await redis_client.setex(cache_key, 300, json.dumps(result))

backend/app/services/reservations.py

@@ -1,46 +1,63 @@
 from datetime import datetime
-from decimal import Decimal
+from decimal import Decimal, ROUND_HALF_UP
 from typing import Dict, Any, List
 
-async def calculate_monthly_revenue(property_id: str, month: int, year: int, db_session=None) -> Decimal:
+async def calculate_monthly_revenue(property_id: str, tenant_id: str, month: int, year: int) -> Dict[str, Any]:
     """
-    Calculates revenue for a specific month.
+    Calculates revenue for reservations checking in during a month,
+    using the property's local time zone for the month boundaries.
     """
-
     start_date = datetime(year, month, 1)
     if month < 12:
         end_date = datetime(year, month + 1, 1)
     else:
         end_date = datetime(year + 1, 1, 1)
-
-    print(f"DEBUG: Querying revenue for {property_id} from {start_date} to {end_date}")
 
-    # SQL Simulation (This would be executed against the actual DB)
-    query = """
-        SELECT SUM(total_amount) as total
-        FROM reservations
-        WHERE property_id = $1
-        AND tenant_id = $2
-        AND check_in_date >= $3
-        AND check_in_date < $4
-    """
-
-    # In production this query executes against a database session.
-    # result = await db.fetch_val(query, property_id, tenant_id, start_date, end_date)
-    # return result or Decimal('0')
-
-    return Decimal('0') # Placeholder for now until DB connection is finalized
+    from app.core.database_pool import db_pool
+    from sqlalchemy import text
+
+    await db_pool.initialize()
+
+    # Convert check-in to property-local time before comparing with naive month bounds.
+    # e.g. 2024-02-29 23:30 UTC is 2024-03-01 00:30 in Europe/Paris, so it counts in March.
+    query = text("""
+        SELECT
+            COALESCE(SUM(r.total_amount), 0) AS total_revenue,
+            COUNT(r.id) AS reservation_count
+        FROM reservations r
+        JOIN properties p ON p.id = r.property_id AND p.tenant_id = r.tenant_id
+        WHERE r.property_id = :property_id
+        AND r.tenant_id = :tenant_id
+        AND (r.check_in_date AT TIME ZONE p.timezone) >= :start_date
+        AND (r.check_in_date AT TIME ZONE p.timezone) < :end_date
+    """)
+
+    async with db_pool.get_session() as session:
+        result = await session.execute(query, {
+            "property_id": property_id,
+            "tenant_id": tenant_id,
+            "start_date": start_date,
+            "end_date": end_date,
+        })
+        row = result.fetchone()
+
+    total = Decimal(str(row.total_revenue)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+    return {
+        "property_id": property_id,
+        "tenant_id": tenant_id,
+        "total": str(total),
+        "currency": "USD",
+        "count": row.reservation_count,
+    }
 
 async def calculate_total_revenue(property_id: str, tenant_id: str) -> Dict[str, Any]:
     """
     Aggregates revenue from database.
     """
     try:
-        # Import database pool
-        from app.core.database_pool import DatabasePool
-
-        # Initialize pool if needed
-        db_pool = DatabasePool()
+        # Reuse the shared pool instead of creating one per request.
+        from app.core.database_pool import db_pool
+
         await db_pool.initialize()
 
         if db_pool.session_factory:
@@ -65,7 +82,8 @@ async def calculate_total_revenue(property_id: str, tenant_id: str) -> Dict[str,
                 row = result.fetchone()
 
                 if row:
-                    total_revenue = Decimal(str(row.total_revenue))
+                    # Amounts are stored to 3 decimals; round once, to cents, after summing.
+                    total_revenue = Decimal(str(row.total_revenue)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
                     return {
                         "property_id": property_id,
                         "tenant_id": tenant_id,
@@ -86,24 +104,6 @@ async def calculate_total_revenue(property_id: str, tenant_id: str) -> Dict[str,
             raise Exception("Database pool not available")
 
     except Exception as e:
+        # Fail loudly: returning placeholder figures hides outages behind wrong numbers.
         print(f"Database error for {property_id} (tenant: {tenant_id}): {e}")
-
-        # Create property-specific mock data for testing when DB is unavailable
-        # This ensures each property shows different figures
-        mock_data = {
-            'prop-001': {'total': '1000.00', 'count': 3},
-            'prop-002': {'total': '4975.50', 'count': 4}, 
-            'prop-003': {'total': '6100.50', 'count': 2},
-            'prop-004': {'total': '1776.50', 'count': 4},
-            'prop-005': {'total': '3256.00', 'count': 3}
-        }
-
-        mock_property_data = mock_data.get(property_id, {'total': '0.00', 'count': 0})
-
-        return {
-            "property_id": property_id,
-            "tenant_id": tenant_id, 
-            "total": mock_property_data['total'],
-            "currency": "USD",
-            "count": mock_property_data['count']
-        }
+        raise

backend/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
     "reportlab>=4.4.3",
     "requests>=2.32.4",
     "sendgrid>=6.12.4",
-    "sqlalchemy>=2.0.0",
+    "sqlalchemy[asyncio]>=2.0.0",
     "stripe>=7.0.0",
     "supabase>=2.18.0",
     "tenacity>=9.1.2",

backend/requirements.txt

@@ -18,7 +18,7 @@ pytz
 redis>=5.0.0
 requests
 sendgrid
-sqlalchemy>=2.0.0
+sqlalchemy[asyncio]>=2.0.0
 supabase
 tenacity>=8.0.0
 uvicorn[standard]