public shares now work

app/models/__init__.py

@@ -1,7 +1,6 @@
 from app.models.user import User
 from app.models.map import Map
 from app.models.map_item import MapItem
-from app.models.share import Share
-from app.models.session import Session
+from app.models.map_share import MapShare, MapShareLink
 
-__all__ = ["User", "Map", "MapItem", "Share", "Session"]
+__all__ = ["User", "Map", "MapItem", "MapShare", "MapShareLink"]

app/models/map_share.py

@@ -20,7 +20,7 @@ class MapShare(Base):
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     map_id = Column(UUID(as_uuid=True), ForeignKey("maps.id", ondelete="CASCADE"), nullable=False, index=True)
     user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
-    permission = Column(SQLEnum(SharePermission), nullable=False, default=SharePermission.READ)
+    permission = Column(SQLEnum(SharePermission, values_callable=lambda x: [e.value for e in x]), nullable=False, default=SharePermission.READ)
     shared_by = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
     updated_at = Column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False)
@@ -34,7 +34,7 @@ class MapShareLink(Base):
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     map_id = Column(UUID(as_uuid=True), ForeignKey("maps.id", ondelete="CASCADE"), nullable=False, index=True)
     token = Column(String(64), unique=True, nullable=False, index=True)  # Random token for the share URL
-    permission = Column(SQLEnum(SharePermission), nullable=False, default=SharePermission.READ)
+    permission = Column(SQLEnum(SharePermission, values_callable=lambda x: [e.value for e in x]), nullable=False, default=SharePermission.READ)
     is_active = Column(Boolean, default=True, nullable=False)
     created_by = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
     expires_at = Column(DateTime(timezone=True), nullable=True)  # Optional expiration

app/routers/items.py

@@ -10,6 +10,7 @@ from app.models.user import User
 from app.schemas.map_item import MapItemCreate, MapItemUpdate, MapItemResponse
 from app.services import item_service
 from app.services.item_service import geography_to_geojson
+from app.websocket.connection_manager import manager
 
 
 router = APIRouter(prefix="/api/maps/{map_id}/items", tags=["map-items"])
@@ -50,7 +51,12 @@ async def create_map_item(
 ):
     """Create a new map item."""
     item = item_service.create_map_item(db, map_id, item_data, current_user)
-    return format_item_response(item)
+    response = format_item_response(item)
+
+    # Broadcast to WebSocket clients
+    await manager.send_item_created(map_id, response)
+
+    return response
 
 
 @router.get("/{item_id}", response_model=dict)
@@ -75,7 +81,12 @@ async def update_map_item(
 ):
     """Update a map item."""
     item = item_service.update_map_item(db, item_id, item_data, current_user)
-    return format_item_response(item)
+    response = format_item_response(item)
+
+    # Broadcast to WebSocket clients
+    await manager.send_item_updated(map_id, response)
+
+    return response
 
 
 @router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
@@ -87,4 +98,8 @@ async def delete_map_item(
 ):
     """Delete a map item."""
     item_service.delete_map_item(db, item_id, current_user)
+
+    # Broadcast to WebSocket clients
+    await manager.send_item_deleted(map_id, str(item_id))
+
     return None

app/routers/websocket.py

@@ -1,11 +1,10 @@
 """WebSocket routes for real-time updates."""
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Depends, Query
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
 from uuid import UUID
 from typing import Optional
 import logging
 
-from app.database import get_db
+from app.database import SessionLocal
 from app.websocket.connection_manager import manager
 from app.services.map_share_service import check_map_access
 from app.dependencies import get_user_from_token
@@ -20,11 +19,10 @@ async def websocket_endpoint(
     websocket: WebSocket,
     map_id: UUID,
     token: Optional[str] = Query(None),
-    share_token: Optional[str] = Query(None),
-    db: Session = Depends(get_db)
+    share_token: Optional[str] = Query(None)
 ):
     """
-    WebSocket endpoint for real-time map updates.
+    WebSocket endpoint for real-time updates.
 
     Clients can connect using:
     - JWT token (authenticated users)
@@ -33,23 +31,38 @@ async def websocket_endpoint(
     Example: ws://localhost:8000/ws/maps/{map_id}?token={jwt_token}
     Example: ws://localhost:8000/ws/maps/{map_id}?share_token={share_token}
     """
-    # Verify access to the map
-    user = None
-    if token:
-        try:
-            user = get_user_from_token(token, db)
-        except Exception as e:
-            logger.error(f"Invalid token: {e}")
-            await websocket.close(code=1008, reason="Invalid token")
+    # Accept the connection first
+    await websocket.accept()
+
+    # Create a temporary DB session just for authentication
+    # This session will be closed immediately after checking access
+    db = SessionLocal()
+    try:
+        # Verify access to the map
+        user = None
+        if token:
+            try:
+                user = get_user_from_token(token, db)
+            except Exception as e:
+                logger.error(f"Invalid token: {e}")
+                await websocket.close(code=1008, reason="Invalid token")
+                return
+
+        # Check map access
+        has_access, permission = check_map_access(db, map_id, user, share_token)
+        if not has_access:
+            await websocket.close(code=1008, reason="Access denied")
             return
 
-    # Check map access
-    has_access, permission = check_map_access(db, map_id, user, share_token)
-    if not has_access:
-        await websocket.close(code=1008, reason="Access denied")
-        return
+        # Store permission for the connection
+        permission_value = permission.value
+    finally:
+        # CRITICAL: Close the DB session immediately after authentication
+        db.close()
 
-    await manager.connect(websocket, map_id)
+    # Add to connection manager (don't call accept again)
+    manager.active_connections.setdefault(str(map_id), set()).add(websocket)
+    logger.info(f"Client connected to map {map_id}. Total connections: {len(manager.active_connections[str(map_id)])}")
 
     try:
         # Send initial connection message
@@ -57,7 +70,7 @@ async def websocket_endpoint(
             "type": "connected",
             "data": {
                 "map_id": str(map_id),
-                "permission": permission.value
+                "permission": permission_value
             }
         })
 

app/services/item_service.py

@@ -6,13 +6,11 @@ from fastapi import HTTPException, status
 from geoalchemy2.shape import from_shape, to_shape
 from shapely.geometry import shape, Point, LineString
 import json
-import asyncio
 
 from app.models.map_item import MapItem
 from app.models.user import User
 from app.schemas.map_item import MapItemCreate, MapItemUpdate
 from app.services.map_service import get_map_by_id
-from app.websocket.connection_manager import manager
 
 
 def get_map_items(db: Session, map_id: UUID, user: Optional[User] = None) -> List[MapItem]:
@@ -60,19 +58,6 @@ def geography_to_geojson(geography) -> dict:
     return json.loads(json.dumps(geom.__geo_interface__))
 
 
-def item_to_dict(item: MapItem) -> dict:
-    """Convert MapItem to JSON-serializable dict for WebSocket broadcast."""
-    return {
-        "id": str(item.id),
-        "map_id": str(item.map_id),
-        "type": item.type,
-        "geometry": geography_to_geojson(item.geometry),
-        "properties": item.properties,
-        "created_at": item.created_at.isoformat(),
-        "updated_at": item.updated_at.isoformat()
-    }
-
-
 def create_map_item(db: Session, map_id: UUID, item_data: MapItemCreate, user: User) -> MapItem:
     """Create a new map item."""
     # Verify user has access to the map
@@ -108,14 +93,6 @@ def create_map_item(db: Session, map_id: UUID, item_data: MapItemCreate, user: U
             print(f"Updating port connections for end device: {end_device_id}")
             update_device_connections(db, UUID(end_device_id), item.id)
 
-    # Broadcast item creation to WebSocket clients
-    try:
-        loop = asyncio.get_event_loop()
-        loop.create_task(manager.send_item_created(map_id, item_to_dict(item)))
-    except RuntimeError:
-        # No event loop running, skip WebSocket broadcast
-        pass
-
     return item
 
 
@@ -178,14 +155,6 @@ def update_map_item(db: Session, item_id: UUID, item_data: MapItemUpdate, user:
     db.commit()
     db.refresh(item)
 
-    # Broadcast item update to WebSocket clients
-    try:
-        loop = asyncio.get_event_loop()
-        loop.create_task(manager.send_item_updated(item.map_id, item_to_dict(item)))
-    except RuntimeError:
-        # No event loop running, skip WebSocket broadcast
-        pass
-
     return item
 
 
@@ -227,14 +196,6 @@ def delete_map_item(db: Session, item_id: UUID, user: User) -> None:
     db.delete(item)
     db.commit()
 
-    # Broadcast item deletion to WebSocket clients
-    try:
-        loop = asyncio.get_event_loop()
-        loop.create_task(manager.send_item_deleted(map_id, deleted_item_id))
-    except RuntimeError:
-        # No event loop running, skip WebSocket broadcast
-        pass
-
 
 def remove_device_connection(db: Session, device_id: UUID, cable_id: UUID) -> None:
     """Remove cable connection from device's connections array."""