Add CP→CA→PI platform foundation on MapMil monorepo.

Unify parsing workers, analytics API with PostgreSQL, map UI, and PI distribution into centers/ with Docker Compose. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-06-30 11:43:27 +03:00
commit 9dfe713668
88 changed files with 6587 additions and 0 deletions
@@ -0,0 +1,23 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:////data/mapmil.db")
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False},
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
@@ -0,0 +1,195 @@
+from contextlib import asynccontextmanager
+
+from fastapi import Depends, FastAPI, File, HTTPException, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from sqlalchemy.orm import Session
+
+from .database import Base, engine, get_db
+from .models import MapObject, ObjectMedia
+from .schemas import MapObjectCreate, MapObjectRead, MapObjectUpdate, ObjectMediaRead
+from .seed import seed_objects
+from .storage import (
+    ALLOWED_CONTENT_TYPES,
+    MAX_FILE_SIZE,
+    build_stored_name,
+    ensure_upload_dir,
+    is_allowed_content_type,
+    media_file_path,
+    remove_media_file,
+)
+
+
+def media_to_read(media: ObjectMedia) -> ObjectMediaRead:
+    return ObjectMediaRead(
+        id=media.id,
+        object_id=media.object_id,
+        original_name=media.original_name,
+        content_type=media.content_type,
+        size=media.size,
+        created_at=media.created_at,
+        url=f"/api/media/{media.id}/file",
+    )
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    ensure_upload_dir()
+    Base.metadata.create_all(bind=engine)
+    db = next(get_db())
+    try:
+        seed_objects(db)
+    finally:
+        db.close()
+    yield
+
+
+app = FastAPI(title="MapMil API", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/api/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.get("/api/objects", response_model=list[MapObjectRead])
+def list_objects(db: Session = Depends(get_db)):
+    return db.query(MapObject).order_by(MapObject.id).all()
+
+
+@app.get("/api/objects/{object_id}", response_model=MapObjectRead)
+def get_object(object_id: int, db: Session = Depends(get_db)):
+    obj = db.query(MapObject).filter(MapObject.id == object_id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Объект не найден")
+    return obj
+
+
+@app.post("/api/objects", response_model=MapObjectRead, status_code=201)
+def create_object(payload: MapObjectCreate, db: Session = Depends(get_db)):
+    data = payload.model_dump()
+    created_at = data.pop("created_at", None)
+    obj = MapObject(**data)
+    if created_at is not None:
+        obj.created_at = created_at
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+@app.patch("/api/objects/{object_id}", response_model=MapObjectRead)
+def update_object(
+    object_id: int,
+    payload: MapObjectUpdate,
+    db: Session = Depends(get_db),
+):
+    obj = db.query(MapObject).filter(MapObject.id == object_id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Объект не найден")
+
+    for field, value in payload.model_dump(exclude_unset=True).items():
+        setattr(obj, field, value)
+
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+@app.delete("/api/objects/{object_id}", status_code=204)
+def delete_object(object_id: int, db: Session = Depends(get_db)):
+    obj = db.query(MapObject).filter(MapObject.id == object_id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Объект не найден")
+
+    for media in obj.media:
+        remove_media_file(media.stored_name)
+
+    db.delete(obj)
+    db.commit()
+
+
+@app.get("/api/objects/{object_id}/media", response_model=list[ObjectMediaRead])
+def list_object_media(object_id: int, db: Session = Depends(get_db)):
+    obj = db.query(MapObject).filter(MapObject.id == object_id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Объект не найден")
+
+    media_items = (
+        db.query(ObjectMedia)
+        .filter(ObjectMedia.object_id == object_id)
+        .order_by(ObjectMedia.id)
+        .all()
+    )
+    return [media_to_read(item) for item in media_items]
+
+
+@app.post("/api/objects/{object_id}/media", response_model=ObjectMediaRead, status_code=201)
+async def upload_object_media(
+    object_id: int,
+    file: UploadFile = File(...),
+    db: Session = Depends(get_db),
+):
+    obj = db.query(MapObject).filter(MapObject.id == object_id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Объект не найден")
+
+    content_type = file.content_type or "application/octet-stream"
+    if not is_allowed_content_type(content_type):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Неподдерживаемый тип файла. Разрешены: {', '.join(sorted(ALLOWED_CONTENT_TYPES))}",
+        )
+
+    content = await file.read()
+    if len(content) > MAX_FILE_SIZE:
+        raise HTTPException(status_code=400, detail="Файл слишком большой (макс. 20 МБ)")
+
+    original_name = file.filename or "file"
+    stored_name = build_stored_name(original_name)
+    path = media_file_path(stored_name)
+    path.write_bytes(content)
+
+    media = ObjectMedia(
+        object_id=object_id,
+        stored_name=stored_name,
+        original_name=original_name,
+        content_type=content_type,
+        size=len(content),
+    )
+    db.add(media)
+    db.commit()
+    db.refresh(media)
+    return media_to_read(media)
+
+
+@app.get("/api/media/{media_id}/file")
+def get_media_file(media_id: int, db: Session = Depends(get_db)):
+    media = db.query(ObjectMedia).filter(ObjectMedia.id == media_id).first()
+    if not media:
+        raise HTTPException(status_code=404, detail="Медиафайл не найден")
+
+    path = media_file_path(media.stored_name)
+    if not path.exists():
+        raise HTTPException(status_code=404, detail="Файл не найден на диске")
+
+    return FileResponse(path, media_type=media.content_type, filename=media.original_name)
+
+
+@app.delete("/api/media/{media_id}", status_code=204)
+def delete_media(media_id: int, db: Session = Depends(get_db)):
+    media = db.query(ObjectMedia).filter(ObjectMedia.id == media_id).first()
+    if not media:
+        raise HTTPException(status_code=404, detail="Медиафайл не найден")
+
+    remove_media_file(media.stored_name)
+    db.delete(media)
+    db.commit()
@@ -0,0 +1,47 @@
+from datetime import datetime, timezone
+
+from sqlalchemy import DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from .database import Base
+
+
+class MapObject(Base):
+    __tablename__ = "map_objects"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    description: Mapped[str] = mapped_column(Text, default="")
+    type: Mapped[str] = mapped_column(String(50), nullable=False)
+    latitude: Mapped[float] = mapped_column(Float, nullable=False)
+    longitude: Mapped[float] = mapped_column(Float, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+    )
+
+    media: Mapped[list["ObjectMedia"]] = relationship(
+        back_populates="object",
+        cascade="all, delete-orphan",
+    )
+
+
+class ObjectMedia(Base):
+    __tablename__ = "object_media"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    object_id: Mapped[int] = mapped_column(
+        ForeignKey("map_objects.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    stored_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    original_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    content_type: Mapped[str] = mapped_column(String(100), nullable=False)
+    size: Mapped[int] = mapped_column(Integer, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+    )
+
+    object: Mapped["MapObject"] = relationship(back_populates="media")
@@ -0,0 +1,48 @@
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+ObjectType = Literal["point", "marker", "zone", "other"]
+
+
+class MapObjectCreate(BaseModel):
+    name: str = Field(min_length=1, max_length=255)
+    description: str = ""
+    type: ObjectType
+    latitude: float = Field(ge=-90, le=90)
+    longitude: float = Field(ge=-180, le=180)
+    created_at: datetime | None = None
+
+
+class MapObjectRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    name: str
+    description: str
+    type: ObjectType
+    latitude: float
+    longitude: float
+    created_at: datetime
+
+
+class MapObjectUpdate(BaseModel):
+    name: str | None = Field(default=None, min_length=1, max_length=255)
+    description: str | None = None
+    type: ObjectType | None = None
+    latitude: float | None = Field(default=None, ge=-90, le=90)
+    longitude: float | None = Field(default=None, ge=-180, le=180)
+    created_at: datetime | None = None
+
+
+class ObjectMediaRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    object_id: int
+    original_name: str
+    content_type: str
+    size: int
+    created_at: datetime
+    url: str
@@ -0,0 +1,54 @@
+from sqlalchemy.orm import Session
+
+from .models import MapObject
+
+from datetime import datetime, timezone
+
+from sqlalchemy.orm import Session
+
+from .models import MapObject
+
+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()
@@ -0,0 +1,39 @@
+import os
+import uuid
+from pathlib import Path
+
+UPLOAD_DIR = Path(os.getenv("UPLOAD_DIR", "/data/uploads"))
+
+ALLOWED_CONTENT_TYPES = {
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+    "video/mp4",
+    "video/webm",
+}
+
+MAX_FILE_SIZE = 20 * 1024 * 1024
+
+
+def ensure_upload_dir() -> None:
+    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def is_allowed_content_type(content_type: str) -> bool:
+    return content_type in ALLOWED_CONTENT_TYPES
+
+
+def build_stored_name(original_name: str) -> str:
+    suffix = Path(original_name).suffix.lower()
+    return f"{uuid.uuid4().hex}{suffix}"
+
+
+def media_file_path(stored_name: str) -> Path:
+    return UPLOAD_DIR / stored_name
+
+
+def remove_media_file(stored_name: str) -> None:
+    path = media_file_path(stored_name)
+    if path.exists():
+        path.unlink()