Refactor map tools and drop SocialParser runtime dependency.

Add filtered map API, creamy-caprice-style toolbar (dates, layers, search), Yandex ru tiles, and store Telegram session in MapMil/data instead of mounting SocialParser.

Co-authored-by: Cursor <cursoragent@cursor.com>

centers/analytics/api/app/main.py

@@ -4,7 +4,7 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from .database import Base, engine, get_db
-from .routers import admin, internal, objects, v1
+from .routers import admin, internal, map, objects, v1
 from .seed import seed_objects, seed_test_consumer
 from .storage import ensure_upload_dir
 
@@ -33,6 +33,7 @@ app.add_middleware(
 )
 
 app.include_router(objects.router)
+app.include_router(map.router)
 app.include_router(internal.router)
 app.include_router(admin.router)
 app.include_router(v1.router)

centers/analytics/api/app/routers/map.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..schemas import MapFiltersRead, MapObjectWithEvent
+from ..services.map_query import (
+    build_map_objects_query,
+    get_map_filters,
+    map_object_to_dict,
+    utc_day_end,
+    utc_day_start,
+)
+
+router = APIRouter(prefix="/api/map", tags=["map"])
+
+
+@router.get("/objects", response_model=list[MapObjectWithEvent])
+def list_map_objects(
+    date_from: datetime | None = None,
+    date_to: datetime | None = None,
+    on_date: datetime | None = Query(default=None, description="Show events for a single day"),
+    region: str | None = None,
+    topic: str | None = None,
+    source_type: str | None = None,
+    search: str | None = None,
+    event_id: int | None = None,
+    db: Session = Depends(get_db),
+):
+    if on_date is not None:
+        date_from = utc_day_start(on_date)
+        date_to = utc_day_end(on_date)
+
+    query = build_map_objects_query(
+        db,
+        date_from=date_from,
+        date_to=date_to,
+        region=region,
+        topic=topic,
+        source_type=source_type,
+        search=search,
+        event_id=event_id,
+    )
+    return [map_object_to_dict(obj) for obj in query.all()]
+
+
+@router.get("/filters", response_model=MapFiltersRead)
+def map_filters(db: Session = Depends(get_db)):
+    return get_map_filters(db)

centers/analytics/api/app/schemas.py

@@ -28,6 +28,29 @@ class MapObjectRead(BaseModel):
     created_at: datetime
 
 
+class MapObjectWithEvent(MapObjectRead):
+    event_date: datetime | None = None
+    locality: str | None = None
+    region: str | None = None
+    topic: str | None = None
+    source_type: str | None = None
+    source_url: str | None = None
+    title: str | None = None
+
+
+class MapDateBounds(BaseModel):
+    min: str | None = None
+    max: str | None = None
+
+
+class MapFiltersRead(BaseModel):
+    regions: list[str]
+    topics: list[str]
+    source_types: list[str]
+    available_dates: list[str]
+    date_bounds: MapDateBounds
+
+
 class MapObjectUpdate(BaseModel):
     name: str | None = Field(default=None, min_length=1, max_length=255)
     description: str | None = None

centers/analytics/api/app/seed.py

@@ -1,55 +1,13 @@
 import os
-from datetime import datetime, timezone
 
 from sqlalchemy.orm import Session
 
-from .models import Consumer, ConsumerFilter, MapObject
+from .models import Consumer, ConsumerFilter
 from .services.filtering import hash_api_key
 
-SEED_OBJECTS = [
-    {
-        "name": "Красная площадь",
-        "description": "Главная площадь Москвы, исторический центр города.",
-        "type": "marker",
-        "latitude": 55.7539,
-        "longitude": 37.6208,
-        "created_at": datetime(2018, 5, 9, 12, 0, tzinfo=timezone.utc),
-    },
-    {
-        "name": "ВДНХ",
-        "description": "Выставка достижений народного хозяйства — крупный выставочный комплекс.",
-        "type": "zone",
-        "latitude": 55.8298,
-        "longitude": 37.6361,
-        "created_at": datetime(2020, 8, 15, 10, 30, tzinfo=timezone.utc),
-    },
-    {
-        "name": "МГУ",
-        "description": "Московский государственный университет имени М.В. Ломоносова.",
-        "type": "point",
-        "latitude": 55.7033,
-        "longitude": 37.5307,
-        "created_at": datetime(2022, 2, 12, 14, 0, tzinfo=timezone.utc),
-    },
-    {
-        "name": "Парк Горького",
-        "description": "Центральный парк культуры и отдыха имени М. Горького.",
-        "type": "other",
-        "latitude": 55.7312,
-        "longitude": 37.6013,
-        "created_at": datetime(2024, 6, 1, 9, 0, tzinfo=timezone.utc),
-    },
-]
-
 
 def seed_objects(db: Session) -> None:
-    if db.query(MapObject).count() > 0:
-        return
-
-    for item in SEED_OBJECTS:
-        db.add(MapObject(**item))
-
-    db.commit()
+    """No demo map objects — map shows ingested events only."""
 
 
 def seed_test_consumer(db: Session) -> None:

centers/analytics/api/app/services/map_query.py

@@ -0,0 +1,168 @@
+from datetime import date, datetime, timezone
+
+from sqlalchemy import func, or_
+from sqlalchemy.orm import Query, Session, joinedload
+
+from ..models import Event, MapObject
+
+
+def _effective_date_column():
+    return func.coalesce(Event.event_date, Event.ingested_at, MapObject.created_at)
+
+
+def build_map_objects_query(
+    db: Session,
+    *,
+    date_from: datetime | None = None,
+    date_to: datetime | None = None,
+    region: str | None = None,
+    topic: str | None = None,
+    source_type: str | None = None,
+    search: str | None = None,
+    event_id: int | None = None,
+) -> Query:
+    query = (
+        db.query(MapObject)
+        .outerjoin(Event, MapObject.event_id == Event.id)
+        .options(joinedload(MapObject.event))
+    )
+
+    if event_id is not None:
+        query = query.filter(MapObject.event_id == event_id)
+
+    effective_date = _effective_date_column()
+
+    if date_from is not None:
+        query = query.filter(effective_date >= date_from)
+    if date_to is not None:
+        query = query.filter(effective_date <= date_to)
+
+    if region:
+        query = query.filter(Event.region == region)
+    if topic:
+        query = query.filter(Event.topic == topic)
+    if source_type:
+        query = query.filter(Event.source_type == source_type)
+
+    if search:
+        pattern = f"%{search}%"
+        query = query.filter(
+            or_(
+                MapObject.name.ilike(pattern),
+                MapObject.description.ilike(pattern),
+                Event.title.ilike(pattern),
+                Event.locality.ilike(pattern),
+                Event.description.ilike(pattern),
+            )
+        )
+
+    return query.order_by(effective_date.desc(), MapObject.id.desc())
+
+
+def map_object_to_dict(obj: MapObject) -> dict:
+    event = obj.event
+    return {
+        "id": obj.id,
+        "name": obj.name,
+        "description": obj.description,
+        "type": obj.type,
+        "latitude": obj.latitude,
+        "longitude": obj.longitude,
+        "event_id": obj.event_id,
+        "created_at": obj.created_at,
+        "event_date": event.event_date if event else obj.created_at,
+        "locality": event.locality if event else None,
+        "region": event.region if event else None,
+        "topic": event.topic if event else None,
+        "source_type": event.source_type if event else None,
+        "source_url": event.source_url if event else None,
+        "title": event.title if event else obj.name,
+    }
+
+
+def _date_to_iso(value: date | datetime | None) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.date().isoformat()
+    return value.isoformat()
+
+
+def get_map_filters(db: Session) -> dict:
+    effective_date = _effective_date_column()
+
+    date_bounds = (
+        db.query(
+            func.min(effective_date).label("min_date"),
+            func.max(effective_date).label("max_date"),
+        )
+        .select_from(MapObject)
+        .outerjoin(Event, MapObject.event_id == Event.id)
+        .first()
+    )
+
+    regions = [
+        row[0]
+        for row in db.query(Event.region)
+        .filter(Event.region.isnot(None), Event.region != "")
+        .distinct()
+        .order_by(Event.region)
+        .all()
+    ]
+
+    topics = [
+        row[0]
+        for row in db.query(Event.topic)
+        .filter(Event.topic.isnot(None), Event.topic != "")
+        .distinct()
+        .order_by(Event.topic)
+        .all()
+    ]
+
+    source_types = [
+        row[0]
+        for row in db.query(Event.source_type)
+        .filter(Event.source_type.isnot(None), Event.source_type != "")
+        .distinct()
+        .order_by(Event.source_type)
+        .all()
+    ]
+
+    available_dates = [
+        _date_to_iso(row[0])
+        for row in (
+            db.query(func.date(effective_date))
+            .select_from(MapObject)
+            .outerjoin(Event, MapObject.event_id == Event.id)
+            .filter(effective_date.isnot(None))
+            .distinct()
+            .order_by(func.date(effective_date))
+            .all()
+        )
+        if row[0] is not None
+    ]
+
+    min_date = date_bounds.min_date if date_bounds else None
+    max_date = date_bounds.max_date if date_bounds else None
+
+    return {
+        "regions": regions,
+        "topics": topics,
+        "source_types": source_types,
+        "available_dates": available_dates,
+        "date_bounds": {
+            "min": min_date.isoformat() if min_date else None,
+            "max": max_date.isoformat() if max_date else None,
+        },
+    }
+
+
+def utc_day_start(dt: datetime) -> datetime:
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+
+
+def utc_day_end(dt: datetime) -> datetime:
+    start = utc_day_start(dt)
+    return start.replace(hour=23, minute=59, second=59, microsecond=999999)