Add STO booking and maintenance automation

README.md

@@ -13,6 +13,9 @@ CarPass — цифровой паспорт автомобиля в Telegram. О
 - Мягкий прогресс заполнения профиля авто: VIN, госномер, пробег, масло, параметры обслуживания.
 - Бейджи качества истории без игровых очков и токсичных рейтингов.
 - Напоминания о ТО, страховке и важных событиях.
+- Автоматические рекомендации ТО по пробегу и времени, включая замену масла.
+- Онлайн-запись в проверенное СТО: выбор услуги, свободного окна, комментарий и согласование времени.
+- Мои записи: статусы requested, confirmed, proposed_new_time, cancelled, completed.
 - OCR чеков и разбор свободного текста: пользователь проверяет найденные данные перед сохранением.
 - История одометра: пробег обновляется из записей, а спорные значения требуют подтверждения.
 
@@ -22,10 +25,33 @@ CarPass — цифровой паспорт автомобиля в Telegram. О
 - Заявка на проверку и статус модерации.
 - Модерация заявок: approved, rejected, needs changes, suspended.
 - Публичная карточка СТО после подтверждения.
+- Каталог СТО показывает только подтвержденные сервисы, город, специализации, рейтинг и ближайшее свободное окно.
+- Кабинет СТО: подключенные авто, новые заявки, подтвержденные записи, активные заказ-наряды, выручка и предупреждения.
+- Настройка графика: рабочие дни, часы, обед, праздники, длительность слота, параллельные записи и онлайн-запись.
+- Календарь записей: заявки клиентов, подтверждение, отклонение, предложение нового времени.
+- Создание заказ-наряда из подтвержденной записи на базе существующего `ServiceVisit`.
 - Отзывы, рейтинг и ответы сервиса.
 - Запрос доступа к конкретному автомобилю только с подтверждением владельца.
 - Добавление визитов, работ и рекомендаций с аудитом действий.
 
+## Запись и обслуживание
+
+Если автомобиль уже привязан к СТО, владелец может открыть карточку авто и записаться сразу в календарь этого сервиса. Если привязки нет, пользователь выбирает СТО из каталога, смотрит свободные окна и создает заявку.
+
+СТО получает уведомление о новой заявке, подтверждает время, отклоняет запись или предлагает другое окно. Когда запись подтверждена, она появляется в календаре СТО. После визита сервис может создать заказ-наряд из записи, провести работы, отправить результат владельцу и обновить историю автомобиля через существующий сценарий подтверждения визита.
+
+## Рекомендации ТО
+
+CarPass создает рекомендации обслуживания из данных автомобиля и истории работ. Сейчас базово поддержана плановая замена масла по интервалу пробега и времени, ручные рекомендации владельца и связь рекомендации с записью в СТО. Просроченные и близкие рекомендации получают приоритет, но формулируются мягко: пользователь видит действие “записаться”, а не тревожную ошибку.
+
+## Уведомления
+
+В системе создаются внутренние уведомления и, если настроен Telegram Bot Token, отправляются сообщения в Telegram:
+
+- СТО получает новую заявку на запись, отмену клиента и решение по предложенному времени.
+- Владелец получает подтверждение, отклонение или предложение нового времени.
+- Рекомендации ТО фиксируются в истории уведомлений.
+
 ## Безопасность данных
 
 CarPass не раскрывает историю автомобиля по одному VIN или госномеру. СТО видит только разрешенный владельцем объем данных: базовую карточку, историю обслуживания или полный доступ. Любые чувствительные изменения, включая VIN, номер, пробег и технические параметры, проходят подтверждение владельца.
@@ -42,6 +68,8 @@ Mini App открывается через кнопку внутри Telegram-б
 - `/fuel`, `/service`, `/insurance`, `/tax`, `/fine` — быстрые записи текстом.
 - `/analytics` — стоимость владения и расход.
 - `/sto`, `/register_sto` — каталог и регистрация СТО.
+- `/appointments` — записи владельца в СТО.
+- `/sto_bookings` — краткий отчет по заявкам и календарю СТО.
 
 ## Почему это полезно
 

alembic/versions/202605150002_sto_booking_automation.py

@@ -0,0 +1,202 @@
+"""sto booking automation
+
+Revision ID: 202605150002
+Revises: 202605150001
+Create Date: 2026-05-15 08:00:00.000000
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision: str = "202605150002"
+down_revision: str | None = "202605150001"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "service_center_booking_settings",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("service_center_id", sa.Integer(), nullable=False),
+        sa.Column("working_days", sa.JSON(), server_default=sa.text("'[0,1,2,3,4]'"), nullable=False),
+        sa.Column("open_time", sa.Time(), server_default="09:00:00", nullable=False),
+        sa.Column("close_time", sa.Time(), server_default="18:00:00", nullable=False),
+        sa.Column("lunch_break_start", sa.Time(), nullable=True),
+        sa.Column("lunch_break_end", sa.Time(), nullable=True),
+        sa.Column("timezone", sa.String(length=64), server_default="Asia/Seoul", nullable=False),
+        sa.Column("slot_duration_minutes", sa.Integer(), server_default="30", nullable=False),
+        sa.Column("booking_buffer_minutes", sa.Integer(), server_default="0", nullable=False),
+        sa.Column("max_parallel_bookings", sa.Integer(), server_default="1", nullable=False),
+        sa.Column("accepts_online_booking", sa.Boolean(), server_default=sa.text("true"), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.ForeignKeyConstraint(["service_center_id"], ["service_centers.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("service_center_id"),
+    )
+    op.create_index("ix_service_center_booking_settings_accepts_online_booking", "service_center_booking_settings", ["accepts_online_booking"])
+    op.create_index("ix_service_center_booking_settings_service_center_id", "service_center_booking_settings", ["service_center_id"])
+
+    op.create_table(
+        "service_center_holidays",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("service_center_id", sa.Integer(), nullable=False),
+        sa.Column("holiday_date", sa.Date(), nullable=False),
+        sa.Column("reason", sa.String(length=240), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.ForeignKeyConstraint(["service_center_id"], ["service_centers.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("service_center_id", "holiday_date", name="uq_service_center_holiday"),
+    )
+    op.create_index("ix_service_center_holidays_holiday_date", "service_center_holidays", ["holiday_date"])
+    op.create_index("ix_service_center_holidays_service_center_id", "service_center_holidays", ["service_center_id"])
+
+    op.create_table(
+        "maintenance_recommendations",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("vehicle_id", sa.Integer(), nullable=False),
+        sa.Column("recommendation_type", sa.String(length=64), nullable=False),
+        sa.Column("title", sa.String(length=180), nullable=False),
+        sa.Column("description", sa.Text(), nullable=True),
+        sa.Column("due_odometer_km", sa.Integer(), nullable=True),
+        sa.Column("due_date", sa.Date(), nullable=True),
+        sa.Column("priority", sa.String(length=24), server_default="medium", nullable=False),
+        sa.Column("status", sa.String(length=24), server_default="active", nullable=False),
+        sa.Column("source", sa.String(length=40), server_default="system_analysis", nullable=False),
+        sa.Column("source_service_center_id", sa.Integer(), nullable=True),
+        sa.Column("source_appointment_id", sa.Integer(), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.ForeignKeyConstraint(["source_service_center_id"], ["service_centers.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["vehicle_id"], ["cars.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_maintenance_recommendations_created_at", "maintenance_recommendations", ["created_at"])
+    op.create_index("ix_maintenance_recommendations_due_date", "maintenance_recommendations", ["due_date"])
+    op.create_index("ix_maintenance_recommendations_due_odometer_km", "maintenance_recommendations", ["due_odometer_km"])
+    op.create_index("ix_maintenance_recommendations_priority", "maintenance_recommendations", ["priority"])
+    op.create_index("ix_maintenance_recommendations_recommendation_type", "maintenance_recommendations", ["recommendation_type"])
+    op.create_index("ix_maintenance_recommendations_source", "maintenance_recommendations", ["source"])
+    op.create_index("ix_maintenance_recommendations_source_appointment_id", "maintenance_recommendations", ["source_appointment_id"])
+    op.create_index("ix_maintenance_recommendations_source_service_center_id", "maintenance_recommendations", ["source_service_center_id"])
+    op.create_index("ix_maintenance_recommendations_status", "maintenance_recommendations", ["status"])
+    op.create_index("ix_maintenance_recommendations_vehicle_id", "maintenance_recommendations", ["vehicle_id"])
+
+    op.create_table(
+        "service_appointments",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("service_center_id", sa.Integer(), nullable=False),
+        sa.Column("vehicle_id", sa.Integer(), nullable=False),
+        sa.Column("owner_id", sa.Integer(), nullable=False),
+        sa.Column("created_by", sa.Integer(), nullable=False),
+        sa.Column("service_type", sa.String(length=64), nullable=False),
+        sa.Column("service_name", sa.String(length=180), nullable=False),
+        sa.Column("requested_start_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("requested_end_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("confirmed_start_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("confirmed_end_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("proposed_start_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("proposed_end_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("estimated_duration_minutes", sa.Integer(), server_default="60", nullable=False),
+        sa.Column("status", sa.String(length=40), server_default="requested", nullable=False),
+        sa.Column("customer_comment", sa.Text(), nullable=True),
+        sa.Column("service_center_comment", sa.Text(), nullable=True),
+        sa.Column("source_recommendation_id", sa.Integer(), nullable=True),
+        sa.Column("linked_work_order_id", sa.Integer(), nullable=True),
+        sa.Column("cancellation_reason", sa.Text(), nullable=True),
+        sa.Column("cancelled_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.ForeignKeyConstraint(["created_by"], ["users.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["linked_work_order_id"], ["service_visits.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["owner_id"], ["users.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["service_center_id"], ["service_centers.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["source_recommendation_id"], ["maintenance_recommendations.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["vehicle_id"], ["cars.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_service_appointments_confirmed_start_at", "service_appointments", ["confirmed_start_at"])
+    op.create_index("ix_service_appointments_created_at", "service_appointments", ["created_at"])
+    op.create_index("ix_service_appointments_created_by", "service_appointments", ["created_by"])
+    op.create_index("ix_service_appointments_linked_work_order_id", "service_appointments", ["linked_work_order_id"])
+    op.create_index("ix_service_appointments_owner_id", "service_appointments", ["owner_id"])
+    op.create_index("ix_service_appointments_proposed_start_at", "service_appointments", ["proposed_start_at"])
+    op.create_index("ix_service_appointments_requested_end_at", "service_appointments", ["requested_end_at"])
+    op.create_index("ix_service_appointments_requested_start_at", "service_appointments", ["requested_start_at"])
+    op.create_index("ix_service_appointments_service_center_id", "service_appointments", ["service_center_id"])
+    op.create_index("ix_service_appointments_service_type", "service_appointments", ["service_type"])
+    op.create_index("ix_service_appointments_source_recommendation_id", "service_appointments", ["source_recommendation_id"])
+    op.create_index("ix_service_appointments_status", "service_appointments", ["status"])
+    op.create_index("ix_service_appointments_vehicle_id", "service_appointments", ["vehicle_id"])
+
+    op.create_table(
+        "service_notifications",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("recipient_user_id", sa.Integer(), nullable=False),
+        sa.Column("service_center_id", sa.Integer(), nullable=True),
+        sa.Column("appointment_id", sa.Integer(), nullable=True),
+        sa.Column("notification_type", sa.String(length=80), nullable=False),
+        sa.Column("title", sa.String(length=180), nullable=False),
+        sa.Column("body", sa.Text(), nullable=True),
+        sa.Column("status", sa.String(length=24), server_default="unread", nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.ForeignKeyConstraint(["appointment_id"], ["service_appointments.id"], ondelete="SET NULL"),
+        sa.ForeignKeyConstraint(["recipient_user_id"], ["users.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(["service_center_id"], ["service_centers.id"], ondelete="SET NULL"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_service_notifications_appointment_id", "service_notifications", ["appointment_id"])
+    op.create_index("ix_service_notifications_created_at", "service_notifications", ["created_at"])
+    op.create_index("ix_service_notifications_notification_type", "service_notifications", ["notification_type"])
+    op.create_index("ix_service_notifications_recipient_user_id", "service_notifications", ["recipient_user_id"])
+    op.create_index("ix_service_notifications_service_center_id", "service_notifications", ["service_center_id"])
+    op.create_index("ix_service_notifications_status", "service_notifications", ["status"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_service_notifications_status", table_name="service_notifications")
+    op.drop_index("ix_service_notifications_service_center_id", table_name="service_notifications")
+    op.drop_index("ix_service_notifications_recipient_user_id", table_name="service_notifications")
+    op.drop_index("ix_service_notifications_notification_type", table_name="service_notifications")
+    op.drop_index("ix_service_notifications_created_at", table_name="service_notifications")
+    op.drop_index("ix_service_notifications_appointment_id", table_name="service_notifications")
+    op.drop_table("service_notifications")
+
+    op.drop_index("ix_service_appointments_vehicle_id", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_status", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_source_recommendation_id", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_service_type", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_service_center_id", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_requested_start_at", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_requested_end_at", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_proposed_start_at", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_owner_id", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_linked_work_order_id", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_created_by", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_created_at", table_name="service_appointments")
+    op.drop_index("ix_service_appointments_confirmed_start_at", table_name="service_appointments")
+    op.drop_table("service_appointments")
+
+    op.drop_index("ix_maintenance_recommendations_vehicle_id", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_status", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_source_service_center_id", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_source_appointment_id", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_source", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_recommendation_type", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_priority", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_due_odometer_km", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_due_date", table_name="maintenance_recommendations")
+    op.drop_index("ix_maintenance_recommendations_created_at", table_name="maintenance_recommendations")
+    op.drop_table("maintenance_recommendations")
+
+    op.drop_index("ix_service_center_holidays_service_center_id", table_name="service_center_holidays")
+    op.drop_index("ix_service_center_holidays_holiday_date", table_name="service_center_holidays")
+    op.drop_table("service_center_holidays")
+
+    op.drop_index("ix_service_center_booking_settings_service_center_id", table_name="service_center_booking_settings")
+    op.drop_index("ix_service_center_booking_settings_accepts_online_booking", table_name="service_center_booking_settings")
+    op.drop_table("service_center_booking_settings")

app/api/sto_booking.py

@@ -0,0 +1,696 @@
+from datetime import UTC, date, datetime, timedelta
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import ensure_service_employee, get_current_telegram_user, log_audit
+from app.db.session import get_session
+from app.models.car import (
+    Car,
+    CarServiceLink,
+    MaintenanceRecommendation,
+    ServiceAppointment,
+    ServiceCenter,
+    ServiceCenterBookingSettings,
+    ServiceCenterHoliday,
+    ServiceVisit,
+)
+from app.models.user import User
+from app.schemas.service_center import ServiceVisitRead
+from app.schemas.sto_booking import (
+    AppointmentCancel,
+    AppointmentCreate,
+    AppointmentCreateWorkOrder,
+    AppointmentDecision,
+    AppointmentProposeTime,
+    AppointmentRead,
+    AvailableSlotRead,
+    MaintenanceRecommendationBook,
+    MaintenanceRecommendationCreate,
+    MaintenanceRecommendationRead,
+    ServiceCatalogItem,
+    ServiceCenterBookingSettingsRead,
+    ServiceCenterBookingSettingsUpsert,
+    ServiceCenterHolidayCreate,
+    ServiceCenterHolidayRead,
+    STODashboardRead,
+)
+from app.services.sto_booking import (
+    calculate_available_slots,
+    create_service_notification,
+    ensure_oil_recommendation,
+    ensure_slot_available,
+    estimate_duration,
+    get_booking_settings,
+    money_to_float,
+    notify_service_staff,
+)
+
+APPROVED_SERVICE_STATUSES = {"verified", "approved"}
+
+router = APIRouter(tags=["sto-booking"])
+
+
+def _utc(value: datetime) -> datetime:
+    if value.tzinfo is None:
+        return value.replace(tzinfo=UTC)
+    return value.astimezone(UTC)
+
+
+async def _approved_service_center(session: AsyncSession, service_center_id: int) -> ServiceCenter:
+    center = await session.get(ServiceCenter, service_center_id)
+    if center is None or center.verification_status not in APPROVED_SERVICE_STATUSES:
+        raise HTTPException(status_code=404, detail="Service center not found")
+    return center
+
+
+async def _owned_vehicle(session: AsyncSession, vehicle_id: int, user: User) -> Car:
+    vehicle = await session.get(Car, vehicle_id)
+    if vehicle is None:
+        raise HTTPException(status_code=404, detail="Vehicle not found")
+    if vehicle.owner_id != user.id:
+        raise HTTPException(status_code=403, detail="Forbidden")
+    return vehicle
+
+
+async def _appointment_for_owner(session: AsyncSession, appointment_id: int, user: User) -> ServiceAppointment:
+    appointment = await session.get(ServiceAppointment, appointment_id)
+    if appointment is None:
+        raise HTTPException(status_code=404, detail="Appointment not found")
+    if appointment.owner_id != user.id:
+        raise HTTPException(status_code=403, detail="Forbidden")
+    return appointment
+
+
+async def _appointment_for_sto(session: AsyncSession, appointment_id: int, user: User) -> ServiceAppointment:
+    appointment = await session.get(ServiceAppointment, appointment_id)
+    if appointment is None:
+        raise HTTPException(status_code=404, detail="Appointment not found")
+    await ensure_service_employee(session, appointment.service_center_id, user, {"owner", "manager", "receptionist"})
+    return appointment
+
+
+@router.get("/sto/catalog", response_model=list[ServiceCatalogItem])
+async def get_sto_catalog(
+    city: str | None = None,
+    specialization: str | None = None,
+    open_today: bool = False,
+    has_slots: bool = False,
+    session: AsyncSession = Depends(get_session),
+) -> list[ServiceCatalogItem]:
+    stmt = select(ServiceCenter).where(ServiceCenter.verification_status.in_(APPROVED_SERVICE_STATUSES))
+    if city:
+        stmt = stmt.where(ServiceCenter.city.ilike(f"%{city}%"))
+    if specialization:
+        stmt = stmt.where(ServiceCenter.specializations.is_not(None))
+    stmt = stmt.order_by(ServiceCenter.rating_avg.desc().nullslast(), ServiceCenter.display_name.asc())
+    centers = list((await session.execute(stmt)).scalars())
+    today = date.today()
+    result: list[ServiceCatalogItem] = []
+    for center in centers:
+        settings = await get_booking_settings(session, center.id)
+        if open_today and today.weekday() not in (settings.working_days or []):
+            continue
+        if specialization and specialization.lower() not in " ".join(center.specializations or []).lower():
+            continue
+        nearest_slot_at = None
+        if has_slots or settings.accepts_online_booking:
+            slots = await calculate_available_slots(
+                session,
+                service_center_id=center.id,
+                date_from=today,
+                date_to=today + timedelta(days=14),
+                duration_minutes=60,
+                limit=1,
+            )
+            nearest_slot_at = slots[0][0] if slots else None
+            if has_slots and nearest_slot_at is None:
+                continue
+        result.append(
+            ServiceCatalogItem(
+                id=center.id,
+                display_name=center.display_name,
+                name=center.name,
+                city=center.city,
+                address=center.address,
+                specializations=center.specializations,
+                working_hours=center.working_hours,
+                rating_avg=float(center.rating_avg) if center.rating_avg is not None else None,
+                reviews_count=center.reviews_count,
+                nearest_slot_at=nearest_slot_at,
+                accepts_online_booking=settings.accepts_online_booking,
+            )
+        )
+    return result
+
+
+@router.get("/sto/{service_center_id}/available-slots", response_model=list[AvailableSlotRead])
+async def get_available_slots(
+    service_center_id: int,
+    service_type: str = "maintenance",
+    date_from: date | None = None,
+    date_to: date | None = None,
+    duration_minutes: int | None = Query(default=None, ge=10, le=1440),
+    session: AsyncSession = Depends(get_session),
+) -> list[AvailableSlotRead]:
+    await _approved_service_center(session, service_center_id)
+    start_date = date_from or date.today()
+    end_date = date_to or start_date + timedelta(days=14)
+    if end_date < start_date:
+        raise HTTPException(status_code=400, detail="date_to must be after date_from")
+    duration = estimate_duration(service_type, duration_minutes)
+    slots = await calculate_available_slots(
+        session,
+        service_center_id=service_center_id,
+        date_from=start_date,
+        date_to=end_date,
+        duration_minutes=duration,
+    )
+    return [AvailableSlotRead(start_at=start, end_at=end) for start, end in slots]
+
+
+@router.post("/appointments", response_model=AppointmentRead, status_code=status.HTTP_201_CREATED)
+async def create_appointment(
+    payload: AppointmentCreate,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    await _approved_service_center(session, payload.service_center_id)
+    vehicle = await _owned_vehicle(session, payload.vehicle_id, current_user)
+    duration = estimate_duration(payload.service_type, payload.estimated_duration_minutes)
+    start_at = _utc(payload.requested_start_at)
+    end_at = await ensure_slot_available(
+        session,
+        service_center_id=payload.service_center_id,
+        start_at=start_at,
+        duration_minutes=duration,
+    )
+    if payload.source_recommendation_id:
+        recommendation = await session.get(MaintenanceRecommendation, payload.source_recommendation_id)
+        if recommendation is None or recommendation.vehicle_id != vehicle.id:
+            raise HTTPException(status_code=400, detail="Recommendation does not belong to vehicle")
+    appointment = ServiceAppointment(
+        service_center_id=payload.service_center_id,
+        vehicle_id=vehicle.id,
+        owner_id=current_user.id,
+        created_by=current_user.id,
+        service_type=payload.service_type,
+        service_name=payload.service_name,
+        requested_start_at=start_at,
+        requested_end_at=end_at,
+        estimated_duration_minutes=duration,
+        status="requested",
+        customer_comment=payload.customer_comment,
+        source_recommendation_id=payload.source_recommendation_id,
+    )
+    session.add(appointment)
+    await session.flush()
+    if payload.source_recommendation_id:
+        recommendation.status = "booked"
+        recommendation.source_appointment_id = appointment.id
+    await notify_service_staff(
+        session,
+        service_center_id=appointment.service_center_id,
+        notification_type="appointment.requested",
+        title="Новая заявка на запись",
+        body=f"{appointment.service_name}: {appointment.requested_start_at:%Y-%m-%d %H:%M}",
+        appointment_id=appointment.id,
+    )
+    await log_audit(
+        session,
+        actor=current_user,
+        action="appointment.create",
+        target_type="service_appointment",
+        target_id=appointment.id,
+    )
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.get("/appointments/my", response_model=list[AppointmentRead])
+async def get_my_appointments(
+    status_filter: str | None = Query(default=None, alias="status"),
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> list[ServiceAppointment]:
+    stmt = (
+        select(ServiceAppointment)
+        .where(ServiceAppointment.owner_id == current_user.id)
+        .order_by(ServiceAppointment.requested_start_at.desc())
+    )
+    if status_filter:
+        stmt = stmt.where(ServiceAppointment.status == status_filter)
+    return list((await session.execute(stmt)).scalars())
+
+
+@router.post("/appointments/{appointment_id}/cancel", response_model=AppointmentRead)
+async def cancel_appointment(
+    appointment_id: int,
+    payload: AppointmentCancel,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    appointment = await _appointment_for_owner(session, appointment_id, current_user)
+    if appointment.status in {"completed", "cancelled_by_customer", "cancelled_by_sto"}:
+        raise HTTPException(status_code=409, detail="Appointment cannot be cancelled")
+    appointment.status = "cancelled_by_customer"
+    appointment.cancelled_at = datetime.now(UTC)
+    appointment.cancellation_reason = payload.reason
+    await notify_service_staff(
+        session,
+        service_center_id=appointment.service_center_id,
+        notification_type="appointment.cancelled_by_customer",
+        title="Клиент отменил запись",
+        body=payload.reason,
+        appointment_id=appointment.id,
+    )
+    await log_audit(session, actor=current_user, action="appointment.cancel", target_type="service_appointment", target_id=appointment_id)
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.post("/appointments/{appointment_id}/accept-proposed-time", response_model=AppointmentRead)
+async def accept_proposed_time(
+    appointment_id: int,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    appointment = await _appointment_for_owner(session, appointment_id, current_user)
+    if appointment.status != "proposed_new_time" or not appointment.proposed_start_at or not appointment.proposed_end_at:
+        raise HTTPException(status_code=409, detail="Appointment has no proposed time")
+    await ensure_slot_available(
+        session,
+        service_center_id=appointment.service_center_id,
+        start_at=appointment.proposed_start_at,
+        duration_minutes=appointment.estimated_duration_minutes,
+        exclude_appointment_id=appointment.id,
+    )
+    appointment.confirmed_start_at = appointment.proposed_start_at
+    appointment.confirmed_end_at = appointment.proposed_end_at
+    appointment.requested_start_at = appointment.proposed_start_at
+    appointment.requested_end_at = appointment.proposed_end_at
+    appointment.status = "confirmed"
+    await notify_service_staff(
+        session,
+        service_center_id=appointment.service_center_id,
+        notification_type="appointment.proposed_time_accepted",
+        title="Клиент принял новое время",
+        appointment_id=appointment.id,
+    )
+    await log_audit(session, actor=current_user, action="appointment.accept_proposed_time", target_type="service_appointment", target_id=appointment_id)
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.post("/appointments/{appointment_id}/reject-proposed-time", response_model=AppointmentRead)
+async def reject_proposed_time(
+    appointment_id: int,
+    payload: AppointmentDecision,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    appointment = await _appointment_for_owner(session, appointment_id, current_user)
+    if appointment.status != "proposed_new_time":
+        raise HTTPException(status_code=409, detail="Appointment has no proposed time")
+    appointment.status = "rejected"
+    appointment.service_center_comment = payload.comment
+    await notify_service_staff(
+        session,
+        service_center_id=appointment.service_center_id,
+        notification_type="appointment.proposed_time_rejected",
+        title="Клиент отклонил новое время",
+        body=payload.comment,
+        appointment_id=appointment.id,
+    )
+    await log_audit(session, actor=current_user, action="appointment.reject_proposed_time", target_type="service_appointment", target_id=appointment_id)
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.get("/sto/dashboard", response_model=STODashboardRead)
+async def get_sto_dashboard(
+    service_center_id: int,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> STODashboardRead:
+    await ensure_service_employee(session, service_center_id, current_user)
+    center = await session.get(ServiceCenter, service_center_id)
+    if center is None:
+        raise HTTPException(status_code=404, detail="Service center not found")
+    month_start = date.today().replace(day=1)
+    connected_vehicles = int(
+        (await session.execute(select(func.count(CarServiceLink.id)).where(
+            CarServiceLink.service_center_id == service_center_id,
+            CarServiceLink.status == "approved",
+            CarServiceLink.is_active.is_(True),
+        ))).scalar_one() or 0
+    )
+    pending_links = int(
+        (await session.execute(select(func.count(CarServiceLink.id)).where(
+            CarServiceLink.service_center_id == service_center_id,
+            CarServiceLink.status == "pending",
+        ))).scalar_one() or 0
+    )
+    pending_appointments = int(
+        (await session.execute(select(func.count(ServiceAppointment.id)).where(
+            ServiceAppointment.service_center_id == service_center_id,
+            ServiceAppointment.status == "requested",
+        ))).scalar_one() or 0
+    )
+    confirmed_appointments = int(
+        (await session.execute(select(func.count(ServiceAppointment.id)).where(
+            ServiceAppointment.service_center_id == service_center_id,
+            ServiceAppointment.status == "confirmed",
+        ))).scalar_one() or 0
+    )
+    active_work_orders = int(
+        (await session.execute(select(func.count(ServiceVisit.id)).where(
+            ServiceVisit.service_center_id == service_center_id,
+            ServiceVisit.status.in_(["draft", "pending_owner_confirmation"]),
+        ))).scalar_one() or 0
+    )
+    completed_result = await session.execute(
+        select(func.count(ServiceVisit.id), func.coalesce(func.sum(ServiceVisit.total_cost), 0)).where(
+            ServiceVisit.service_center_id == service_center_id,
+            ServiceVisit.status == "confirmed",
+            ServiceVisit.visit_date >= month_start,
+        )
+    )
+    completed_count, revenue_month = completed_result.one()
+    average_check = money_to_float(revenue_month) / int(completed_count or 1)
+    warnings = []
+    settings = await get_booking_settings(session, service_center_id)
+    if not settings.accepts_online_booking:
+        warnings.append("online_booking_disabled")
+    if pending_links:
+        warnings.append("pending_vehicle_links")
+    if pending_appointments:
+        warnings.append("pending_appointments")
+    if not center.facade_photo_url:
+        warnings.append("missing_facade_photo")
+    return STODashboardRead(
+        service_center_id=service_center_id,
+        connected_vehicles=connected_vehicles,
+        pending_vehicle_links=pending_links,
+        active_appointments=pending_appointments + confirmed_appointments,
+        pending_appointments=pending_appointments,
+        confirmed_appointments=confirmed_appointments,
+        active_work_orders=active_work_orders,
+        completed_work_orders_month=int(completed_count or 0),
+        revenue_month=money_to_float(revenue_month),
+        average_check_month=average_check,
+        rating_avg=float(center.rating_avg) if center.rating_avg is not None else None,
+        reviews_count=center.reviews_count,
+        warnings=warnings,
+    )
+
+
+@router.get("/sto/calendar", response_model=list[AppointmentRead])
+async def get_sto_calendar(
+    service_center_id: int,
+    date_from: datetime | None = None,
+    date_to: datetime | None = None,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> list[ServiceAppointment]:
+    await ensure_service_employee(session, service_center_id, current_user)
+    start_at = _utc(date_from or datetime.now(UTC) - timedelta(days=1))
+    end_at = _utc(date_to or start_at + timedelta(days=30))
+    stmt = (
+        select(ServiceAppointment)
+        .where(
+            ServiceAppointment.service_center_id == service_center_id,
+            ServiceAppointment.requested_start_at >= start_at,
+            ServiceAppointment.requested_start_at <= end_at,
+        )
+        .order_by(ServiceAppointment.requested_start_at.asc())
+    )
+    return list((await session.execute(stmt)).scalars())
+
+
+@router.get("/sto/appointments", response_model=list[AppointmentRead])
+async def get_sto_appointments(
+    service_center_id: int,
+    status_filter: str | None = Query(default=None, alias="status"),
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> list[ServiceAppointment]:
+    await ensure_service_employee(session, service_center_id, current_user)
+    stmt = select(ServiceAppointment).where(ServiceAppointment.service_center_id == service_center_id)
+    if status_filter:
+        stmt = stmt.where(ServiceAppointment.status == status_filter)
+    stmt = stmt.order_by(ServiceAppointment.requested_start_at.desc())
+    return list((await session.execute(stmt)).scalars())
+
+
+@router.post("/sto/appointments/{appointment_id}/confirm", response_model=AppointmentRead)
+async def confirm_appointment(
+    appointment_id: int,
+    payload: AppointmentDecision,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    appointment = await _appointment_for_sto(session, appointment_id, current_user)
+    if appointment.status not in {"requested", "proposed_new_time"}:
+        raise HTTPException(status_code=409, detail="Appointment cannot be confirmed")
+    await ensure_slot_available(
+        session,
+        service_center_id=appointment.service_center_id,
+        start_at=appointment.requested_start_at,
+        duration_minutes=appointment.estimated_duration_minutes,
+        exclude_appointment_id=appointment.id,
+    )
+    appointment.status = "confirmed"
+    appointment.confirmed_start_at = appointment.requested_start_at
+    appointment.confirmed_end_at = appointment.requested_end_at
+    appointment.service_center_comment = payload.comment
+    await create_service_notification(
+        session,
+        recipient_user_id=appointment.owner_id,
+        service_center_id=appointment.service_center_id,
+        appointment_id=appointment.id,
+        notification_type="appointment.confirmed",
+        title="СТО подтвердило запись",
+        body=f"{appointment.service_name}: {appointment.confirmed_start_at:%Y-%m-%d %H:%M}",
+    )
+    await log_audit(session, actor=current_user, action="appointment.confirm", target_type="service_appointment", target_id=appointment_id)
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.post("/sto/appointments/{appointment_id}/reject", response_model=AppointmentRead)
+async def reject_appointment(
+    appointment_id: int,
+    payload: AppointmentDecision,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    appointment = await _appointment_for_sto(session, appointment_id, current_user)
+    if appointment.status in {"completed", "cancelled_by_customer", "cancelled_by_sto"}:
+        raise HTTPException(status_code=409, detail="Appointment cannot be rejected")
+    appointment.status = "rejected"
+    appointment.service_center_comment = payload.comment
+    await create_service_notification(
+        session,
+        recipient_user_id=appointment.owner_id,
+        service_center_id=appointment.service_center_id,
+        appointment_id=appointment.id,
+        notification_type="appointment.rejected",
+        title="СТО отклонило запись",
+        body=payload.comment,
+    )
+    await log_audit(session, actor=current_user, action="appointment.reject", target_type="service_appointment", target_id=appointment_id)
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.post("/sto/appointments/{appointment_id}/propose-time", response_model=AppointmentRead)
+async def propose_appointment_time(
+    appointment_id: int,
+    payload: AppointmentProposeTime,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceAppointment:
+    appointment = await _appointment_for_sto(session, appointment_id, current_user)
+    if appointment.status in {"completed", "cancelled_by_customer", "cancelled_by_sto"}:
+        raise HTTPException(status_code=409, detail="Appointment cannot be changed")
+    duration = estimate_duration(appointment.service_type, payload.estimated_duration_minutes or appointment.estimated_duration_minutes)
+    proposed_start = _utc(payload.proposed_start_at)
+    proposed_end = await ensure_slot_available(
+        session,
+        service_center_id=appointment.service_center_id,
+        start_at=proposed_start,
+        duration_minutes=duration,
+        exclude_appointment_id=appointment.id,
+    )
+    appointment.estimated_duration_minutes = duration
+    appointment.proposed_start_at = proposed_start
+    appointment.proposed_end_at = proposed_end
+    appointment.status = "proposed_new_time"
+    appointment.service_center_comment = payload.comment
+    await create_service_notification(
+        session,
+        recipient_user_id=appointment.owner_id,
+        service_center_id=appointment.service_center_id,
+        appointment_id=appointment.id,
+        notification_type="appointment.proposed_new_time",
+        title="СТО предложило другое время",
+        body=f"{proposed_start:%Y-%m-%d %H:%M}",
+    )
+    await log_audit(session, actor=current_user, action="appointment.propose_time", target_type="service_appointment", target_id=appointment_id)
+    await session.commit()
+    await session.refresh(appointment)
+    return appointment
+
+
+@router.post("/sto/appointments/{appointment_id}/create-work-order", response_model=ServiceVisitRead, status_code=status.HTTP_201_CREATED)
+async def create_work_order_from_appointment(
+    appointment_id: int,
+    payload: AppointmentCreateWorkOrder,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceVisit:
+    appointment = await _appointment_for_sto(session, appointment_id, current_user)
+    employee = await ensure_service_employee(session, appointment.service_center_id, current_user, {"owner", "manager", "receptionist"})
+    if appointment.status != "confirmed":
+        raise HTTPException(status_code=409, detail="Only confirmed appointment can become work order")
+    if appointment.linked_work_order_id:
+        visit = await session.get(ServiceVisit, appointment.linked_work_order_id)
+        if visit is None:
+            raise HTTPException(status_code=404, detail="Linked work order not found")
+        return visit
+    visit = ServiceVisit(
+        service_center_id=appointment.service_center_id,
+        vehicle_id=appointment.vehicle_id,
+        created_by_employee_id=employee.id,
+        visit_date=(appointment.confirmed_start_at or appointment.requested_start_at).date(),
+        odometer=payload.odometer,
+        status="draft",
+        notes=payload.notes or appointment.customer_comment,
+    )
+    session.add(visit)
+    await session.flush()
+    appointment.linked_work_order_id = visit.id
+    await log_audit(session, actor=current_user, action="appointment.create_work_order", target_type="service_appointment", target_id=appointment_id, metadata={"service_visit_id": visit.id})
+    await session.commit()
+    await session.refresh(visit)
+    return visit
+
+
+@router.post("/sto/settings/booking", response_model=ServiceCenterBookingSettingsRead)
+async def upsert_booking_settings(
+    payload: ServiceCenterBookingSettingsUpsert,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceCenterBookingSettings:
+    await ensure_service_employee(session, payload.service_center_id, current_user, {"owner", "manager"})
+    settings = await get_booking_settings(session, payload.service_center_id)
+    for field, value in payload.model_dump(exclude={"service_center_id"}).items():
+        setattr(settings, field, value)
+    await log_audit(session, actor=current_user, action="sto_booking_settings.update", target_type="service_center", target_id=payload.service_center_id)
+    await session.commit()
+    await session.refresh(settings)
+    return settings
+
+
+@router.post("/sto/settings/holidays", response_model=ServiceCenterHolidayRead, status_code=status.HTTP_201_CREATED)
+async def create_holiday(
+    payload: ServiceCenterHolidayCreate,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> ServiceCenterHoliday:
+    await ensure_service_employee(session, payload.service_center_id, current_user, {"owner", "manager"})
+    holiday = ServiceCenterHoliday(**payload.model_dump())
+    session.add(holiday)
+    await log_audit(session, actor=current_user, action="sto_holiday.create", target_type="service_center", target_id=payload.service_center_id)
+    await session.commit()
+    await session.refresh(holiday)
+    return holiday
+
+
+@router.get("/vehicles/{vehicle_id}/maintenance-recommendations", response_model=list[MaintenanceRecommendationRead])
+async def get_maintenance_recommendations(
+    vehicle_id: int,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> list[MaintenanceRecommendation]:
+    vehicle = await _owned_vehicle(session, vehicle_id, current_user)
+    await ensure_oil_recommendation(session, vehicle)
+    await session.commit()
+    stmt = (
+        select(MaintenanceRecommendation)
+        .where(MaintenanceRecommendation.vehicle_id == vehicle_id)
+        .order_by(MaintenanceRecommendation.status.asc(), MaintenanceRecommendation.due_date.asc().nullslast())
+    )
+    return list((await session.execute(stmt)).scalars())
+
+
+@router.post("/vehicles/{vehicle_id}/maintenance-recommendations", response_model=MaintenanceRecommendationRead, status_code=status.HTTP_201_CREATED)
+async def create_maintenance_recommendation(
+    vehicle_id: int,
+    payload: MaintenanceRecommendationCreate,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> MaintenanceRecommendation:
+    await _owned_vehicle(session, vehicle_id, current_user)
+    recommendation = MaintenanceRecommendation(vehicle_id=vehicle_id, status="active", **payload.model_dump())
+    session.add(recommendation)
+    await create_service_notification(
+        session,
+        recipient_user_id=current_user.id,
+        notification_type="maintenance_recommendation.created",
+        title="Добавлена рекомендация ТО",
+        body=payload.title,
+        send_telegram=False,
+    )
+    await log_audit(session, actor=current_user, action="maintenance_recommendation.create", target_type="vehicle", target_id=vehicle_id)
+    await session.commit()
+    await session.refresh(recommendation)
+    return recommendation
+
+
+@router.post("/maintenance-recommendations/{recommendation_id}/dismiss", response_model=MaintenanceRecommendationRead)
+async def dismiss_maintenance_recommendation(
+    recommendation_id: int,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> MaintenanceRecommendation:
+    recommendation = await session.get(MaintenanceRecommendation, recommendation_id)
+    if recommendation is None:
+        raise HTTPException(status_code=404, detail="Recommendation not found")
+    await _owned_vehicle(session, recommendation.vehicle_id, current_user)
+    recommendation.status = "dismissed"
+    await log_audit(session, actor=current_user, action="maintenance_recommendation.dismiss", target_type="maintenance_recommendation", target_id=recommendation_id)
+    await session.commit()
+    await session.refresh(recommendation)
+    return recommendation
+
+
+@router.post("/maintenance-recommendations/{recommendation_id}/book", response_model=MaintenanceRecommendationRead)
+async def mark_recommendation_booked(
+    recommendation_id: int,
+    payload: MaintenanceRecommendationBook,
+    session: AsyncSession = Depends(get_session),
+    current_user: User = Depends(get_current_telegram_user),
+) -> MaintenanceRecommendation:
+    recommendation = await session.get(MaintenanceRecommendation, recommendation_id)
+    if recommendation is None:
+        raise HTTPException(status_code=404, detail="Recommendation not found")
+    await _owned_vehicle(session, recommendation.vehicle_id, current_user)
+    appointment = await _appointment_for_owner(session, payload.appointment_id, current_user)
+    if appointment.vehicle_id != recommendation.vehicle_id:
+        raise HTTPException(status_code=400, detail="Appointment does not match recommendation vehicle")
+    recommendation.status = "booked"
+    recommendation.source_appointment_id = appointment.id
+    appointment.source_recommendation_id = recommendation.id
+    await log_audit(session, actor=current_user, action="maintenance_recommendation.book", target_type="maintenance_recommendation", target_id=recommendation_id, metadata={"appointment_id": appointment.id})
+    await session.commit()
+    await session.refresh(recommendation)
+    return recommendation

app/main.py

@@ -14,6 +14,7 @@ from app.api import (
     parser,
     service_centers,
     service_visits,
+    sto_booking,
     users,
 )
 from app.core.config import settings
@@ -40,6 +41,7 @@ app.include_router(gamification.router, prefix="/api")
 app.include_router(ocr.router, prefix="/api")
 app.include_router(parser.router, prefix="/api")
 app.include_router(service_centers.router, prefix="/api")
+app.include_router(sto_booking.router, prefix="/api")
 app.include_router(service_visits.router, prefix="/api")
 app.include_router(change_requests.router, prefix="/api")
 app.include_router(admin.router, prefix="/api")

app/models/car.py

@@ -1,4 +1,4 @@
-from datetime import date, datetime
+from datetime import date, datetime, time
 from decimal import Decimal
 
 from sqlalchemy import (
@@ -11,6 +11,7 @@ from sqlalchemy import (
     Numeric,
     String,
     Text,
+    Time,
     UniqueConstraint,
     func,
 )
@@ -163,6 +164,14 @@ class ServiceCenter(Base):
     employees = relationship("ServiceEmployee", back_populates="service_center", cascade="all, delete-orphan")
     visits = relationship("ServiceVisit", back_populates="service_center")
     reviews = relationship("ServiceCenterReview", back_populates="service_center", cascade="all, delete-orphan")
+    booking_settings = relationship(
+        "ServiceCenterBookingSettings",
+        back_populates="service_center",
+        cascade="all, delete-orphan",
+        uselist=False,
+    )
+    holidays = relationship("ServiceCenterHoliday", back_populates="service_center", cascade="all, delete-orphan")
+    appointments = relationship("ServiceAppointment", back_populates="service_center", cascade="all, delete-orphan")
 
 
 class CarServiceLink(Base):
@@ -260,6 +269,44 @@ class ServiceEmployee(Base):
     service_center = relationship("ServiceCenter", back_populates="employees")
 
 
+class ServiceCenterBookingSettings(Base):
+    __tablename__ = "service_center_booking_settings"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    service_center_id: Mapped[int] = mapped_column(
+        ForeignKey("service_centers.id", ondelete="CASCADE"), unique=True, index=True
+    )
+    working_days: Mapped[list] = mapped_column(JSON, default=lambda: [0, 1, 2, 3, 4], server_default="[0,1,2,3,4]")
+    open_time: Mapped[time] = mapped_column(Time, default=time(9, 0), server_default="09:00:00")
+    close_time: Mapped[time] = mapped_column(Time, default=time(18, 0), server_default="18:00:00")
+    lunch_break_start: Mapped[time | None] = mapped_column(Time)
+    lunch_break_end: Mapped[time | None] = mapped_column(Time)
+    timezone: Mapped[str] = mapped_column(String(64), default="Asia/Seoul", server_default="Asia/Seoul")
+    slot_duration_minutes: Mapped[int] = mapped_column(Integer, default=30, server_default="30")
+    booking_buffer_minutes: Mapped[int] = mapped_column(Integer, default=0, server_default="0")
+    max_parallel_bookings: Mapped[int] = mapped_column(Integer, default=1, server_default="1")
+    accepts_online_booking: Mapped[bool] = mapped_column(Boolean, default=True, server_default="true", index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )
+
+    service_center = relationship("ServiceCenter", back_populates="booking_settings")
+
+
+class ServiceCenterHoliday(Base):
+    __tablename__ = "service_center_holidays"
+    __table_args__ = (UniqueConstraint("service_center_id", "holiday_date", name="uq_service_center_holiday"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    service_center_id: Mapped[int] = mapped_column(ForeignKey("service_centers.id", ondelete="CASCADE"), index=True)
+    holiday_date: Mapped[date] = mapped_column(Date, index=True)
+    reason: Mapped[str | None] = mapped_column(String(240))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+
+    service_center = relationship("ServiceCenter", back_populates="holidays")
+
+
 class ServiceVisit(Base):
     __tablename__ = "service_visits"
 
@@ -283,6 +330,75 @@ class ServiceVisit(Base):
     work_items = relationship("ServiceWorkItem", back_populates="visit", cascade="all, delete-orphan")
 
 
+class MaintenanceRecommendation(Base):
+    __tablename__ = "maintenance_recommendations"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vehicle_id: Mapped[int] = mapped_column(ForeignKey("cars.id", ondelete="CASCADE"), index=True)
+    recommendation_type: Mapped[str] = mapped_column(String(64), index=True)
+    title: Mapped[str] = mapped_column(String(180))
+    description: Mapped[str | None] = mapped_column(Text)
+    due_odometer_km: Mapped[int | None] = mapped_column(Integer, index=True)
+    due_date: Mapped[date | None] = mapped_column(Date, index=True)
+    priority: Mapped[str] = mapped_column(String(24), default="medium", server_default="medium", index=True)
+    status: Mapped[str] = mapped_column(String(24), default="active", server_default="active", index=True)
+    source: Mapped[str] = mapped_column(String(40), default="system_analysis", server_default="system_analysis", index=True)
+    source_service_center_id: Mapped[int | None] = mapped_column(ForeignKey("service_centers.id", ondelete="SET NULL"), index=True)
+    source_appointment_id: Mapped[int | None] = mapped_column(Integer, index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), index=True)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )
+
+
+class ServiceAppointment(Base):
+    __tablename__ = "service_appointments"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    service_center_id: Mapped[int] = mapped_column(ForeignKey("service_centers.id", ondelete="CASCADE"), index=True)
+    vehicle_id: Mapped[int] = mapped_column(ForeignKey("cars.id", ondelete="CASCADE"), index=True)
+    owner_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True)
+    created_by: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True)
+    service_type: Mapped[str] = mapped_column(String(64), index=True)
+    service_name: Mapped[str] = mapped_column(String(180))
+    requested_start_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), index=True)
+    requested_end_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), index=True)
+    confirmed_start_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), index=True)
+    confirmed_end_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    proposed_start_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), index=True)
+    proposed_end_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    estimated_duration_minutes: Mapped[int] = mapped_column(Integer, default=60, server_default="60")
+    status: Mapped[str] = mapped_column(String(40), default="requested", server_default="requested", index=True)
+    customer_comment: Mapped[str | None] = mapped_column(Text)
+    service_center_comment: Mapped[str | None] = mapped_column(Text)
+    source_recommendation_id: Mapped[int | None] = mapped_column(
+        ForeignKey("maintenance_recommendations.id", ondelete="SET NULL"), index=True
+    )
+    linked_work_order_id: Mapped[int | None] = mapped_column(ForeignKey("service_visits.id", ondelete="SET NULL"), index=True)
+    cancellation_reason: Mapped[str | None] = mapped_column(Text)
+    cancelled_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), index=True)
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )
+
+    service_center = relationship("ServiceCenter", back_populates="appointments")
+
+
+class ServiceNotification(Base):
+    __tablename__ = "service_notifications"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    recipient_user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), index=True)
+    service_center_id: Mapped[int | None] = mapped_column(ForeignKey("service_centers.id", ondelete="SET NULL"), index=True)
+    appointment_id: Mapped[int | None] = mapped_column(ForeignKey("service_appointments.id", ondelete="SET NULL"), index=True)
+    notification_type: Mapped[str] = mapped_column(String(80), index=True)
+    title: Mapped[str] = mapped_column(String(180))
+    body: Mapped[str | None] = mapped_column(Text)
+    status: Mapped[str] = mapped_column(String(24), default="unread", server_default="unread", index=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), index=True)
+
+
 class ServiceWorkItem(Base):
     __tablename__ = "service_work_items"
 

app/schemas/sto_booking.py

@@ -0,0 +1,187 @@
+from datetime import date, datetime, time
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+APPOINTMENT_STATUSES = {
+    "draft",
+    "requested",
+    "confirmed",
+    "proposed_new_time",
+    "rejected",
+    "cancelled_by_customer",
+    "cancelled_by_sto",
+    "completed",
+    "no_show",
+}
+
+
+class AvailableSlotRead(BaseModel):
+    start_at: datetime
+    end_at: datetime
+
+
+class ServiceCatalogItem(BaseModel):
+    id: int
+    display_name: str | None = None
+    name: str
+    city: str | None = None
+    address: str | None = None
+    specializations: list[str] | None = None
+    working_hours: str | None = None
+    rating_avg: float | None = None
+    reviews_count: int = 0
+    nearest_slot_at: datetime | None = None
+    accepts_online_booking: bool = True
+
+
+class ServiceCenterBookingSettingsUpsert(BaseModel):
+    service_center_id: int
+    working_days: list[int] = Field(default_factory=lambda: [0, 1, 2, 3, 4])
+    open_time: time = time(9, 0)
+    close_time: time = time(18, 0)
+    lunch_break_start: time | None = None
+    lunch_break_end: time | None = None
+    timezone: str = "Asia/Seoul"
+    slot_duration_minutes: int = Field(default=30, ge=10, le=240)
+    booking_buffer_minutes: int = Field(default=0, ge=0, le=240)
+    max_parallel_bookings: int = Field(default=1, ge=1, le=20)
+    accepts_online_booking: bool = True
+
+    @field_validator("working_days")
+    @classmethod
+    def validate_working_days(cls, value: list[int]) -> list[int]:
+        days = sorted(set(value))
+        if any(day < 0 or day > 6 for day in days):
+            raise ValueError("working_days must contain ISO weekdays 0..6")
+        return days
+
+    @model_validator(mode="after")
+    def validate_times(self) -> "ServiceCenterBookingSettingsUpsert":
+        if self.open_time >= self.close_time:
+            raise ValueError("open_time must be before close_time")
+        if bool(self.lunch_break_start) != bool(self.lunch_break_end):
+            raise ValueError("both lunch break boundaries are required")
+        if self.lunch_break_start and self.lunch_break_end and self.lunch_break_start >= self.lunch_break_end:
+            raise ValueError("lunch_break_start must be before lunch_break_end")
+        return self
+
+
+class ServiceCenterBookingSettingsRead(ServiceCenterBookingSettingsUpsert):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ServiceCenterHolidayCreate(BaseModel):
+    service_center_id: int
+    holiday_date: date
+    reason: str | None = None
+
+
+class ServiceCenterHolidayRead(ServiceCenterHolidayCreate):
+    id: int
+    created_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class AppointmentCreate(BaseModel):
+    service_center_id: int
+    vehicle_id: int
+    service_type: str = Field(default="maintenance", max_length=64)
+    service_name: str = Field(default="Обслуживание", max_length=180)
+    requested_start_at: datetime
+    estimated_duration_minutes: int = Field(default=60, ge=10, le=1440)
+    customer_comment: str | None = Field(default=None, max_length=4000)
+    source_recommendation_id: int | None = None
+
+
+class AppointmentRead(BaseModel):
+    id: int
+    service_center_id: int
+    vehicle_id: int
+    owner_id: int
+    created_by: int
+    service_type: str
+    service_name: str
+    requested_start_at: datetime
+    requested_end_at: datetime
+    confirmed_start_at: datetime | None = None
+    confirmed_end_at: datetime | None = None
+    proposed_start_at: datetime | None = None
+    proposed_end_at: datetime | None = None
+    estimated_duration_minutes: int
+    status: str
+    customer_comment: str | None = None
+    service_center_comment: str | None = None
+    source_recommendation_id: int | None = None
+    linked_work_order_id: int | None = None
+    cancellation_reason: str | None = None
+    cancelled_at: datetime | None = None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class AppointmentDecision(BaseModel):
+    comment: str | None = Field(default=None, max_length=4000)
+
+
+class AppointmentProposeTime(BaseModel):
+    proposed_start_at: datetime
+    estimated_duration_minutes: int | None = Field(default=None, ge=10, le=1440)
+    comment: str | None = Field(default=None, max_length=4000)
+
+
+class AppointmentCancel(BaseModel):
+    reason: str | None = Field(default=None, max_length=1000)
+
+
+class AppointmentCreateWorkOrder(BaseModel):
+    odometer: int | None = None
+    notes: str | None = Field(default=None, max_length=4000)
+
+
+class MaintenanceRecommendationCreate(BaseModel):
+    recommendation_type: str = Field(max_length=64)
+    title: str = Field(max_length=180)
+    description: str | None = None
+    due_odometer_km: int | None = None
+    due_date: date | None = None
+    priority: str = "medium"
+    source: str = "user_rule"
+
+
+class MaintenanceRecommendationRead(MaintenanceRecommendationCreate):
+    id: int
+    vehicle_id: int
+    status: str
+    source_service_center_id: int | None = None
+    source_appointment_id: int | None = None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class MaintenanceRecommendationBook(BaseModel):
+    appointment_id: int
+
+
+class STODashboardRead(BaseModel):
+    service_center_id: int
+    connected_vehicles: int
+    pending_vehicle_links: int
+    active_appointments: int
+    pending_appointments: int
+    confirmed_appointments: int
+    active_work_orders: int
+    completed_work_orders_month: int
+    revenue_month: float
+    average_check_month: float
+    rating_avg: float | None = None
+    reviews_count: int
+    warnings: list[str]

app/services/sto_booking.py

@@ -0,0 +1,338 @@
+from datetime import UTC, date, datetime, time, timedelta
+from decimal import Decimal
+
+from fastapi import HTTPException
+from sqlalchemy import func, or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.car import (
+    Car,
+    MaintenanceRecommendation,
+    ServiceAppointment,
+    ServiceCenter,
+    ServiceCenterBookingSettings,
+    ServiceCenterHoliday,
+    ServiceEmployee,
+    ServiceNotification,
+    ServiceVisit,
+    ServiceWorkItem,
+)
+from app.models.expense import ServiceEntry
+from app.models.user import User
+from app.services.notifications import notify_user
+
+ACTIVE_APPOINTMENT_STATUSES = {"requested", "confirmed", "proposed_new_time"}
+DEFAULT_SERVICE_DURATIONS = {
+    "oil_change": 60,
+    "diagnostics": 60,
+    "repair": 120,
+    "tire_service": 60,
+    "brakes": 90,
+    "fluids": 60,
+    "maintenance": 90,
+    "other": 60,
+}
+
+
+def _as_aware_utc(value: datetime) -> datetime:
+    if value.tzinfo is None:
+        return value.replace(tzinfo=UTC)
+    return value.astimezone(UTC)
+
+
+def estimate_duration(service_type: str, requested: int | None = None) -> int:
+    return requested or DEFAULT_SERVICE_DURATIONS.get(service_type, DEFAULT_SERVICE_DURATIONS["other"])
+
+
+async def get_booking_settings(
+    session: AsyncSession, service_center_id: int
+) -> ServiceCenterBookingSettings:
+    result = await session.execute(
+        select(ServiceCenterBookingSettings).where(
+            ServiceCenterBookingSettings.service_center_id == service_center_id
+        )
+    )
+    settings = result.scalar_one_or_none()
+    if settings is not None:
+        return settings
+    settings = ServiceCenterBookingSettings(service_center_id=service_center_id)
+    session.add(settings)
+    await session.flush()
+    return settings
+
+
+def _slot_overlaps_lunch(start_time: time, end_time: time, settings: ServiceCenterBookingSettings) -> bool:
+    if not settings.lunch_break_start or not settings.lunch_break_end:
+        return False
+    return start_time < settings.lunch_break_end and end_time > settings.lunch_break_start
+
+
+async def count_overlapping_appointments(
+    session: AsyncSession,
+    *,
+    service_center_id: int,
+    start_at: datetime,
+    end_at: datetime,
+    exclude_appointment_id: int | None = None,
+) -> int:
+    start_at = _as_aware_utc(start_at)
+    end_at = _as_aware_utc(end_at)
+    stmt = select(func.count(ServiceAppointment.id)).where(
+        ServiceAppointment.service_center_id == service_center_id,
+        ServiceAppointment.status.in_(ACTIVE_APPOINTMENT_STATUSES),
+        ServiceAppointment.requested_start_at < end_at,
+        ServiceAppointment.requested_end_at > start_at,
+    )
+    if exclude_appointment_id:
+        stmt = stmt.where(ServiceAppointment.id != exclude_appointment_id)
+    return int((await session.execute(stmt)).scalar_one() or 0)
+
+
+async def ensure_slot_available(
+    session: AsyncSession,
+    *,
+    service_center_id: int,
+    start_at: datetime,
+    duration_minutes: int,
+    exclude_appointment_id: int | None = None,
+) -> datetime:
+    start_at = _as_aware_utc(start_at)
+    now = datetime.now(UTC)
+    if start_at <= now:
+        raise HTTPException(status_code=409, detail="Cannot book past time")
+    end_at = start_at + timedelta(minutes=duration_minutes)
+    settings = await get_booking_settings(session, service_center_id)
+    if not settings.accepts_online_booking:
+        raise HTTPException(status_code=409, detail="Online booking is disabled")
+    holiday = await session.execute(
+        select(ServiceCenterHoliday).where(
+            ServiceCenterHoliday.service_center_id == service_center_id,
+            ServiceCenterHoliday.holiday_date == start_at.date(),
+        )
+    )
+    if holiday.scalar_one_or_none() is not None:
+        raise HTTPException(status_code=409, detail="Service center is closed on this date")
+    working_days = settings.working_days or [0, 1, 2, 3, 4]
+    if start_at.weekday() not in working_days:
+        raise HTTPException(status_code=409, detail="Service center is closed on this weekday")
+    if start_at.time() < settings.open_time or end_at.time() > settings.close_time:
+        raise HTTPException(status_code=409, detail="Slot is outside working hours")
+    if _slot_overlaps_lunch(start_at.time(), end_at.time(), settings):
+        raise HTTPException(status_code=409, detail="Slot overlaps lunch break")
+    overlapping = await count_overlapping_appointments(
+        session,
+        service_center_id=service_center_id,
+        start_at=start_at,
+        end_at=end_at,
+        exclude_appointment_id=exclude_appointment_id,
+    )
+    if overlapping >= settings.max_parallel_bookings:
+        raise HTTPException(status_code=409, detail="Slot is already full")
+    return end_at
+
+
+async def calculate_available_slots(
+    session: AsyncSession,
+    *,
+    service_center_id: int,
+    date_from: date,
+    date_to: date,
+    duration_minutes: int,
+    limit: int = 80,
+) -> list[tuple[datetime, datetime]]:
+    settings = await get_booking_settings(session, service_center_id)
+    holidays = {
+        item.holiday_date
+        for item in (
+            await session.execute(
+                select(ServiceCenterHoliday).where(
+                    ServiceCenterHoliday.service_center_id == service_center_id,
+                    ServiceCenterHoliday.holiday_date >= date_from,
+                    ServiceCenterHoliday.holiday_date <= date_to,
+                )
+            )
+        ).scalars()
+    }
+    slots: list[tuple[datetime, datetime]] = []
+    now = datetime.now(UTC)
+    current = date_from
+    step = timedelta(minutes=settings.slot_duration_minutes + settings.booking_buffer_minutes)
+    working_days = settings.working_days or [0, 1, 2, 3, 4]
+    while current <= date_to and len(slots) < limit:
+        if current.weekday() not in working_days or current in holidays:
+            current += timedelta(days=1)
+            continue
+        cursor = datetime.combine(current, settings.open_time, tzinfo=UTC)
+        day_close = datetime.combine(current, settings.close_time, tzinfo=UTC)
+        while cursor + timedelta(minutes=duration_minutes) <= day_close and len(slots) < limit:
+            end_at = cursor + timedelta(minutes=duration_minutes)
+            if cursor > now and not _slot_overlaps_lunch(cursor.time(), end_at.time(), settings):
+                overlapping = await count_overlapping_appointments(
+                    session,
+                    service_center_id=service_center_id,
+                    start_at=cursor,
+                    end_at=end_at,
+                )
+                if overlapping < settings.max_parallel_bookings:
+                    slots.append((cursor, end_at))
+            cursor += step
+        current += timedelta(days=1)
+    return slots
+
+
+async def create_service_notification(
+    session: AsyncSession,
+    *,
+    recipient_user_id: int,
+    notification_type: str,
+    title: str,
+    body: str | None = None,
+    service_center_id: int | None = None,
+    appointment_id: int | None = None,
+    send_telegram: bool = True,
+) -> ServiceNotification:
+    notification = ServiceNotification(
+        recipient_user_id=recipient_user_id,
+        service_center_id=service_center_id,
+        appointment_id=appointment_id,
+        notification_type=notification_type,
+        title=title,
+        body=body,
+    )
+    session.add(notification)
+    if send_telegram:
+        user = await session.get(User, recipient_user_id)
+        if user is not None:
+            await notify_user(user, f"{title}\n{body}" if body else title)
+    return notification
+
+
+async def notify_service_staff(
+    session: AsyncSession,
+    *,
+    service_center_id: int,
+    notification_type: str,
+    title: str,
+    body: str | None = None,
+    appointment_id: int | None = None,
+) -> None:
+    center = await session.get(ServiceCenter, service_center_id)
+    recipient_ids: set[int] = set()
+    if center and center.owner_user_id:
+        recipient_ids.add(center.owner_user_id)
+    employees = await session.execute(
+        select(ServiceEmployee).where(
+            ServiceEmployee.service_center_id == service_center_id,
+            ServiceEmployee.status == "active",
+        )
+    )
+    recipient_ids.update(employee.user_id for employee in employees.scalars())
+    for user_id in recipient_ids:
+        await create_service_notification(
+            session,
+            recipient_user_id=user_id,
+            notification_type=notification_type,
+            title=title,
+            body=body,
+            service_center_id=service_center_id,
+            appointment_id=appointment_id,
+        )
+
+
+def _recommendation_priority(car: Car, due_odometer: int | None, due_date: date | None) -> str:
+    today = date.today()
+    current_odometer = car.current_odometer or 0
+    if due_odometer is not None and current_odometer >= due_odometer:
+        return "overdue"
+    if due_date is not None and today >= due_date:
+        return "overdue"
+    if due_odometer is not None and due_odometer - current_odometer <= 1000:
+        return "high"
+    if due_date is not None and (due_date - today).days <= 14:
+        return "high"
+    return "medium"
+
+
+async def ensure_oil_recommendation(session: AsyncSession, car: Car) -> MaintenanceRecommendation | None:
+    interval_km = car.oil_change_interval_km or 10_000
+    interval_months = car.oil_change_interval_months or 12
+    latest_entry = (
+        await session.execute(
+            select(ServiceEntry)
+            .where(
+                ServiceEntry.car_id == car.id,
+                or_(
+                    ServiceEntry.title.ilike("%масл%"),
+                    ServiceEntry.title.ilike("%oil%"),
+                    ServiceEntry.category.ilike("%масл%"),
+                    ServiceEntry.category.ilike("%oil%"),
+                ),
+            )
+            .order_by(ServiceEntry.entry_date.desc(), ServiceEntry.id.desc())
+        )
+    ).scalars().first()
+    latest_work_item = (
+        await session.execute(
+            select(ServiceWorkItem, ServiceVisit)
+            .join(ServiceVisit, ServiceVisit.id == ServiceWorkItem.service_visit_id)
+            .where(
+                ServiceVisit.vehicle_id == car.id,
+                or_(
+                    ServiceWorkItem.work_type.in_(["oil_change", "fluids"]),
+                    ServiceWorkItem.title.ilike("%масл%"),
+                    ServiceWorkItem.title.ilike("%oil%"),
+                ),
+            )
+            .order_by(ServiceVisit.visit_date.desc(), ServiceWorkItem.id.desc())
+        )
+    ).first()
+    base_odometer = car.current_odometer or 0
+    base_date = date.today()
+    if latest_entry:
+        base_odometer = latest_entry.odometer or base_odometer
+        base_date = latest_entry.entry_date or base_date
+    if latest_work_item:
+        work_item, visit = latest_work_item
+        base_odometer = visit.odometer or base_odometer
+        base_date = visit.visit_date or base_date
+        if work_item.next_due_odometer:
+            due_odometer = work_item.next_due_odometer
+        else:
+            due_odometer = base_odometer + interval_km
+        due_date = work_item.next_due_date or (base_date + timedelta(days=interval_months * 30))
+    else:
+        due_odometer = base_odometer + interval_km
+        due_date = base_date + timedelta(days=interval_months * 30)
+    existing = (
+        await session.execute(
+            select(MaintenanceRecommendation).where(
+                MaintenanceRecommendation.vehicle_id == car.id,
+                MaintenanceRecommendation.recommendation_type == "oil_change",
+                MaintenanceRecommendation.status == "active",
+            )
+        )
+    ).scalar_one_or_none()
+    priority = _recommendation_priority(car, due_odometer, due_date)
+    payload = {
+        "vehicle_id": car.id,
+        "recommendation_type": "oil_change",
+        "title": "Замена моторного масла",
+        "description": "Плановая рекомендация по интервалу пробега и времени.",
+        "due_odometer_km": due_odometer,
+        "due_date": due_date,
+        "priority": priority,
+        "source": "mileage_interval",
+    }
+    if existing:
+        for key, value in payload.items():
+            setattr(existing, key, value)
+        await session.flush()
+        return existing
+    recommendation = MaintenanceRecommendation(**payload)
+    session.add(recommendation)
+    await session.flush()
+    return recommendation
+
+
+def money_to_float(value: Decimal | None) -> float:
+    return float(value or 0)

bot/api_client.py

@@ -88,6 +88,28 @@ class ApiClient:
     async def public_service_centers(self, telegram_id: int) -> list[dict[str, Any]]:
         return await self.request("GET", "/api/service-centers/public", telegram_id=telegram_id)
 
+    async def sto_catalog(self, telegram_id: int) -> list[dict[str, Any]]:
+        return await self.request("GET", "/api/sto/catalog", telegram_id=telegram_id)
+
+    async def my_appointments(self, telegram_id: int) -> list[dict[str, Any]]:
+        return await self.request("GET", "/api/appointments/my", telegram_id=telegram_id)
+
+    async def sto_dashboard(self, telegram_id: int, service_center_id: int) -> dict[str, Any]:
+        return await self.request(
+            "GET",
+            "/api/sto/dashboard",
+            telegram_id=telegram_id,
+            params={"service_center_id": service_center_id},
+        )
+
+    async def sto_appointments(self, telegram_id: int, service_center_id: int) -> list[dict[str, Any]]:
+        return await self.request(
+            "GET",
+            "/api/sto/appointments",
+            telegram_id=telegram_id,
+            params={"service_center_id": service_center_id, "status": "requested"},
+        )
+
     async def my_service_centers(self, telegram_id: int) -> list[dict[str, Any]]:
         return await self.request("GET", "/api/service-centers/my", telegram_id=telegram_id)
 

bot/main.py

@@ -271,7 +271,7 @@ async def analytics(message: Message) -> None:
 async def sto(message: Message) -> None:
     await upsert(message)
     try:
-        centers = await api.public_service_centers(message.from_user.id)
+        centers = await api.sto_catalog(message.from_user.id)
     except httpx.HTTPStatusError:
         centers = []
     if not centers:
@@ -281,12 +281,66 @@ async def sto(message: Message) -> None:
         )
         return
     text = "Проверенные СТО:\n" + "\n".join(
-        f"{item['id']}. {item.get('display_name') or item.get('name')} — {item.get('city') or 'город не указан'}"
+        (
+            f"{item['id']}. {item.get('display_name') or item.get('name')} — {item.get('city') or 'город не указан'}"
+            f"{' · ближайшее окно ' + item['nearest_slot_at'][:16].replace('T', ' ') if item.get('nearest_slot_at') else ''}"
+        )
         for item in centers[:10]
     )
     await message.answer(text, reply_markup=webapp_inline_keyboard("Каталог СТО"))
 
 
+@dp.message(Command("appointments"))
+async def appointments(message: Message) -> None:
+    await upsert(message)
+    try:
+        items = await api.my_appointments(message.from_user.id)
+    except httpx.HTTPStatusError as error:
+        await message.answer(f"Записи не загрузились: {error.response.text}")
+        return
+    if not items:
+        await message.answer(
+            "Активных записей пока нет. В Mini App можно выбрать авто, СТО и свободное окно.",
+            reply_markup=webapp_inline_keyboard("Записаться в СТО"),
+        )
+        return
+    lines = ["Ваши записи:"]
+    for item in items[:10]:
+        lines.append(
+            f"#{item['id']} {item['service_name']} — {item['requested_start_at'][:16].replace('T', ' ')} · {item['status']}"
+        )
+    await message.answer("\n".join(lines), reply_markup=webapp_inline_keyboard("Мои записи"))
+
+
+@dp.message(Command("sto_bookings"))
+async def sto_bookings(message: Message) -> None:
+    await upsert(message)
+    try:
+        centers = await api.my_service_centers(message.from_user.id)
+    except httpx.HTTPStatusError as error:
+        await message.answer(f"Кабинет СТО не доступен: {error.response.text}")
+        return
+    if not centers:
+        await message.answer("У вас пока нет СТО. Подайте заявку через /register_sto или Mini App.")
+        return
+    center = centers[0]
+    try:
+        dashboard = await api.sto_dashboard(message.from_user.id, center["id"])
+        pending = await api.sto_appointments(message.from_user.id, center["id"])
+    except httpx.HTTPStatusError as error:
+        await message.answer(f"Заявки СТО не загрузились: {error.response.text}")
+        return
+    lines = [
+        f"Кабинет СТО: {center.get('display_name') or center.get('name')}",
+        f"Авто: {dashboard['connected_vehicles']}",
+        f"Новые заявки: {dashboard['pending_appointments']}",
+        f"Подтверждено: {dashboard['confirmed_appointments']}",
+    ]
+    for item in pending[:8]:
+        lines.append(f"#{item['id']} {item['service_name']} — {item['requested_start_at'][:16].replace('T', ' ')}")
+    await message.answer("\n".join(lines), reply_markup=webapp_inline_keyboard("Кабинет СТО"))
+
+
 @dp.message(Command("register_sto"))
 async def register_sto(message: Message, command: CommandObject) -> None:
     await upsert(message)
@@ -464,7 +518,11 @@ async def help_message(message: Message) -> None:
         "• /insurance, /tax, /fine — регулярные и разовые расходы;\n"
         "• /analytics — стоимость владения и расход;\n"
         "• /sto — каталог проверенных СТО;\n"
+        "• /appointments — мои записи в СТО;\n"
+        "• /sto_bookings — заявки и календарь для владельца СТО;\n"
         "• /register_sto — заявка на СТО.\n\n"
+        "Для ТО: в карточке авто Mini App показывает рекомендации, доступные СТО, свободные окна, запись и согласование времени.\n"
+        "Для СТО: настрой график, принимай заявки, создавай заказ-наряд из подтвержденной записи и отправляй клиенту результат работ.\n\n"
         "Mini App открывай только кнопкой под сообщением: Telegram передает initData, и авторизация проходит корректно.",
         reply_markup=menu_inline_keyboard(),
     )

tests/test_sto_booking.py

@@ -0,0 +1,266 @@
+from datetime import UTC, date, datetime, time, timedelta
+
+import pytest
+
+
+def next_weekday(target: int) -> date:
+    today = date.today()
+    delta = (target - today.weekday()) % 7
+    if delta == 0:
+        delta = 7
+    return today + timedelta(days=delta)
+
+
+async def create_verified_center(client, owner_headers, admin_headers, internal_headers, *, city: str = "Seoul") -> dict:
+    center = (
+        await client.post(
+            "/api/service-centers",
+            headers=owner_headers,
+            json={
+                "display_name": f"Booking Service {city}",
+                "country": "KR",
+                "city": city,
+                "specializations": ["oil_change", "diagnostics"],
+            },
+        )
+    ).json()
+    await client.post(
+        "/api/users",
+        headers=internal_headers,
+        json={"telegram_id": 9001, "platform_role": "admin"},
+    )
+    response = await client.post(f"/api/admin/service-centers/{center['id']}/verify", headers=admin_headers)
+    assert response.status_code == 200
+    return response.json()
+
+
+@pytest.mark.asyncio
+async def test_sto_catalog_shows_only_approved_and_filters_city(
+    client, auth_headers, admin_auth_headers, internal_headers
+) -> None:
+    approved = await create_verified_center(client, auth_headers, admin_auth_headers, internal_headers, city="Seoul")
+    await client.post(
+        "/api/service-centers",
+        headers=auth_headers,
+        json={"display_name": "Pending Booking Service", "country": "KR", "city": "Busan"},
+    )
+
+    response = await client.get("/api/sto/catalog?city=Seoul", headers=auth_headers)
+
+    assert response.status_code == 200
+    ids = [item["id"] for item in response.json()]
+    assert ids == [approved["id"]]
+
+
+@pytest.mark.asyncio
+async def test_available_slots_skip_weekend_lunch_and_holidays(
+    client, auth_headers, admin_auth_headers, internal_headers
+) -> None:
+    center = await create_verified_center(client, auth_headers, admin_auth_headers, internal_headers)
+    monday = next_weekday(0)
+    saturday = next_weekday(5)
+    await client.post(
+        "/api/sto/settings/booking",
+        headers=auth_headers,
+        json={
+            "service_center_id": center["id"],
+            "working_days": [0],
+            "open_time": "09:00:00",
+            "close_time": "13:00:00",
+            "lunch_break_start": "11:00:00",
+            "lunch_break_end": "12:00:00",
+            "slot_duration_minutes": 60,
+            "max_parallel_bookings": 1,
+            "accepts_online_booking": True,
+        },
+    )
+    await client.post(
+        "/api/sto/settings/holidays",
+        headers=auth_headers,
+        json={"service_center_id": center["id"], "holiday_date": saturday.isoformat(), "reason": "Closed"},
+    )
+
+    monday_slots = (
+        await client.get(
+            f"/api/sto/{center['id']}/available-slots?date_from={monday}&date_to={monday}&duration_minutes=60",
+            headers=auth_headers,
+        )
+    ).json()
+    saturday_slots = (
+        await client.get(
+            f"/api/sto/{center['id']}/available-slots?date_from={saturday}&date_to={saturday}&duration_minutes=60",
+            headers=auth_headers,
+        )
+    ).json()
+
+    assert {datetime.fromisoformat(slot["start_at"]).time() for slot in monday_slots} == {time(9, 0), time(10, 0), time(12, 0)}
+    assert saturday_slots == []
+
+
+@pytest.mark.asyncio
+async def test_customer_booking_lifecycle_capacity_calendar_work_order_and_notifications(
+    client, auth_headers, other_auth_headers, admin_auth_headers, internal_headers
+) -> None:
+    center = await create_verified_center(client, auth_headers, admin_auth_headers, internal_headers)
+    workday = next_weekday(0)
+    start_at = datetime.combine(workday, time(10, 0), tzinfo=UTC)
+    proposed_at = datetime.combine(workday, time(14, 0), tzinfo=UTC)
+    await client.post(
+        "/api/sto/settings/booking",
+        headers=auth_headers,
+        json={
+            "service_center_id": center["id"],
+            "working_days": [0, 1, 2, 3, 4],
+            "open_time": "09:00:00",
+            "close_time": "18:00:00",
+            "slot_duration_minutes": 60,
+            "max_parallel_bookings": 1,
+            "accepts_online_booking": True,
+        },
+    )
+    vehicle = (
+        await client.post(
+            "/api/my/vehicles",
+            headers=other_auth_headers,
+            json={"name": "Client car", "current_odometer": 45000, "oil_change_interval_km": 10000},
+        )
+    ).json()
+
+    past_response = await client.post(
+        "/api/appointments",
+        headers=other_auth_headers,
+        json={
+            "service_center_id": center["id"],
+            "vehicle_id": vehicle["id"],
+            "service_type": "oil_change",
+            "service_name": "Oil change",
+            "requested_start_at": (datetime.now(UTC) - timedelta(days=1)).isoformat(),
+            "estimated_duration_minutes": 60,
+        },
+    )
+    assert past_response.status_code == 409
+
+    created = await client.post(
+        "/api/appointments",
+        headers=other_auth_headers,
+        json={
+            "service_center_id": center["id"],
+            "vehicle_id": vehicle["id"],
+            "service_type": "oil_change",
+            "service_name": "Oil change",
+            "requested_start_at": start_at.isoformat(),
+            "estimated_duration_minutes": 60,
+            "customer_comment": "Need synthetic oil",
+        },
+    )
+    assert created.status_code == 201
+    appointment = created.json()
+    assert appointment["status"] == "requested"
+
+    duplicate = await client.post(
+        "/api/appointments",
+        headers=other_auth_headers,
+        json={
+            "service_center_id": center["id"],
+            "vehicle_id": vehicle["id"],
+            "service_type": "diagnostics",
+            "service_name": "Diagnostics",
+            "requested_start_at": start_at.isoformat(),
+            "estimated_duration_minutes": 60,
+        },
+    )
+    assert duplicate.status_code == 409
+
+    proposed = await client.post(
+        f"/api/sto/appointments/{appointment['id']}/propose-time",
+        headers=auth_headers,
+        json={"proposed_start_at": proposed_at.isoformat(), "comment": "Better window"},
+    )
+    assert proposed.status_code == 200
+    assert proposed.json()["status"] == "proposed_new_time"
+
+    accepted = await client.post(
+        f"/api/appointments/{appointment['id']}/accept-proposed-time",
+        headers=other_auth_headers,
+    )
+    assert accepted.status_code == 200
+    assert accepted.json()["status"] == "confirmed"
+
+    calendar = await client.get(
+        f"/api/sto/calendar?service_center_id={center['id']}&date_from={workday.isoformat()}T00:00:00Z&date_to={workday.isoformat()}T23:59:59Z",
+        headers=auth_headers,
+    )
+    assert calendar.status_code == 200
+    assert calendar.json()[0]["id"] == appointment["id"]
+
+    work_order = await client.post(
+        f"/api/sto/appointments/{appointment['id']}/create-work-order",
+        headers=auth_headers,
+        json={"odometer": 45100},
+    )
+    assert work_order.status_code == 201
+    assert work_order.json()["vehicle_id"] == vehicle["id"]
+
+    my_appointments = await client.get("/api/appointments/my", headers=other_auth_headers)
+    assert my_appointments.json()[0]["linked_work_order_id"] == work_order.json()["id"]
+
+
+@pytest.mark.asyncio
+async def test_recommendations_can_be_generated_dismissed_and_linked_to_booking(
+    client, auth_headers, other_auth_headers, admin_auth_headers, internal_headers
+) -> None:
+    center = await create_verified_center(client, auth_headers, admin_auth_headers, internal_headers)
+    workday = next_weekday(1)
+    start_at = datetime.combine(workday, time(10, 0), tzinfo=UTC)
+    vehicle = (
+        await client.post(
+            "/api/my/vehicles",
+            headers=other_auth_headers,
+            json={"name": "Recommendation car", "current_odometer": 90000, "oil_change_interval_km": 10000},
+        )
+    ).json()
+
+    recommendations = await client.get(
+        f"/api/vehicles/{vehicle['id']}/maintenance-recommendations",
+        headers=other_auth_headers,
+    )
+    assert recommendations.status_code == 200
+    oil_recommendation = recommendations.json()[0]
+    assert oil_recommendation["recommendation_type"] == "oil_change"
+
+    appointment = (
+        await client.post(
+            "/api/appointments",
+            headers=other_auth_headers,
+            json={
+                "service_center_id": center["id"],
+                "vehicle_id": vehicle["id"],
+                "service_type": "oil_change",
+                "service_name": "Oil change",
+                "requested_start_at": start_at.isoformat(),
+                "estimated_duration_minutes": 60,
+                "source_recommendation_id": oil_recommendation["id"],
+            },
+        )
+    ).json()
+    booked = await client.post(
+        f"/api/maintenance-recommendations/{oil_recommendation['id']}/book",
+        headers=other_auth_headers,
+        json={"appointment_id": appointment["id"]},
+    )
+    assert booked.status_code == 200
+    assert booked.json()["status"] == "booked"
+
+    custom = (
+        await client.post(
+            f"/api/vehicles/{vehicle['id']}/maintenance-recommendations",
+            headers=other_auth_headers,
+            json={"recommendation_type": "brakes", "title": "Check brakes", "priority": "low"},
+        )
+    ).json()
+    dismissed = await client.post(
+        f"/api/maintenance-recommendations/{custom['id']}/dismiss",
+        headers=other_auth_headers,
+    )
+    assert dismissed.status_code == 200
+    assert dismissed.json()["status"] == "dismissed"

web/index.html

@@ -254,9 +254,12 @@
         <button class="menu-row" data-menu-section="taxSection">Налоги</button>
         <button class="menu-row" data-menu-section="fineSection">Штрафы</button>
         <button class="menu-row" data-menu-section="publicServicesSection">СТО</button>
+        <button class="menu-row" data-menu-section="appointmentsSection">Мои записи</button>
+        <button class="menu-row" data-menu-section="maintenanceRecommendationsSection">Рекомендации ТО</button>
         <button class="menu-row" data-menu-section="reviewsSection">Отзывы</button>
         <button class="menu-row" data-menu-section="confirmationsSection">Подтверждения</button>
         <button class="menu-row" data-menu-section="connectedServicesSection">Подключённые СТО</button>
+        <button class="menu-row" data-menu-section="stoCalendarSection">Календарь СТО</button>
         <button class="menu-row admin-only hidden" data-menu-section="adminSection">Админ</button>
         <button class="menu-row" data-menu-section="settingsSection">Настройки</button>
 
@@ -405,6 +408,18 @@
           <div id="serviceReviews" class="stack-list"></div>
         </section>
 
+        <section class="drawer-section hidden" id="appointmentsSection">
+          <h2>Мои записи</h2>
+          <div class="tip-card">Здесь видны заявки, подтвержденные записи и предложения нового времени от СТО.</div>
+          <div id="appointmentsList" class="stack-list"></div>
+        </section>
+
+        <section class="drawer-section hidden" id="maintenanceRecommendationsSection">
+          <h2>Рекомендации ТО</h2>
+          <div class="tip-card">CarPass подсказывает обслуживание по пробегу, времени и истории работ.</div>
+          <div id="maintenanceRecommendations" class="stack-list"></div>
+        </section>
+
         <section class="drawer-section hidden" id="settingsSection">
           <h2>Настройки</h2>
           <form id="settingsForm" class="grid-form drawer-form">
@@ -512,6 +527,13 @@
           <div id="serviceCentersList" class="stack-list"></div>
         </section>
 
+        <section class="drawer-section hidden" id="stoCalendarSection">
+          <h2>Календарь СТО</h2>
+          <div class="tip-card">Краткая сводка заявок и подтвержденных записей по первому доступному СТО.</div>
+          <div id="stoDashboardSummary" class="stats mini-stats"></div>
+          <div id="stoCalendarList" class="stack-list"></div>
+        </section>
+
         <section class="drawer-section hidden" id="adminSection">
           <h2>Модерация СТО</h2>
           <div class="tip-card">Заявки видны только администраторам и модераторам.</div>

web/static/app.js

@@ -319,6 +319,9 @@ const state = {
   analytics: null,
   serviceCenters: [],
   publicServiceCenters: [],
+  appointments: [],
+  maintenanceRecommendations: [],
+  stoCalendar: [],
   confirmations: null,
   connectedServices: [],
   adminPendingServices: [],
@@ -1060,7 +1063,7 @@ async function loadPublicServiceCenters() {
   const root = document.querySelector("#publicServiceCenters");
   if (!root) return;
   try {
-    const centers = await api("/service-centers/public");
+    const centers = await api("/sto/catalog");
     state.publicServiceCenters = centers;
     root.innerHTML = centers.length
       ? centers
@@ -1070,7 +1073,7 @@ async function loadPublicServiceCenters() {
               <strong>${center.display_name || center.name}</strong>
               <small>${[center.city, center.address].filter(Boolean).join(", ") || "Адрес не указан"}</small>
               <small>${center.specializations?.join(", ") || "Специализация не указана"}</small>
-              <span class="trust-badge">${center.rating_avg ? `★ ${center.rating_avg}` : "Проверка пройдена"}</span>
+              <span class="trust-badge">${center.nearest_slot_at ? `Окно ${formatDateTime(center.nearest_slot_at)}` : center.rating_avg ? `★ ${center.rating_avg}` : "Проверка пройдена"}</span>
             </button>
           `,
         )
@@ -1124,6 +1127,33 @@ async function openServiceCard(serviceCenterId) {
     <div class="service-actions">
       <button type="button" class="ghost-btn" id="attachServiceBtn">Привязать выбранное авто</button>
     </div>
+    <form class="grid-form drawer-form" id="serviceBookingForm">
+      <label>
+        Услуга
+        <select name="service_type">
+          <option value="oil_change">Замена масла</option>
+          <option value="diagnostics">Диагностика</option>
+          <option value="maintenance">ТО</option>
+          <option value="tire_service">Шиномонтаж</option>
+          <option value="brakes">Тормоза</option>
+          <option value="repair">Ремонт</option>
+          <option value="other">Другое</option>
+        </select>
+      </label>
+      <label>
+        Дата
+        <input name="date" type="date" value="${today()}" />
+      </label>
+      <label>
+        Свободное окно
+        <select name="slot" id="bookingSlotSelect"></select>
+      </label>
+      <label>
+        Комментарий
+        <input name="customer_comment" placeholder="Что нужно сделать" />
+      </label>
+      <button type="submit">Записаться</button>
+    </form>
     <form class="grid-form drawer-form" id="serviceReviewForm">
       <label>
         Оценка
@@ -1182,9 +1212,212 @@ async function openServiceCard(serviceCenterId) {
       haptic("success");
     });
   });
+  const bookingForm = card.querySelector("#serviceBookingForm");
+  const reloadSlots = () => loadServiceBookingSlots(serviceCenterId, bookingForm);
+  bookingForm.querySelector('[name="service_type"]').addEventListener("change", reloadSlots);
+  bookingForm.querySelector('[name="date"]').addEventListener("change", reloadSlots);
+  bookingForm.addEventListener("submit", async (event) => {
+    event.preventDefault();
+    if (!state.selectedCarId) {
+      toast("Выбери автомобиль", "error");
+      return;
+    }
+    const data = formData(bookingForm);
+    if (!data.slot) {
+      toast("Выбери свободное окно", "error");
+      return;
+    }
+    await runAction(bookingForm.querySelector('button[type="submit"]'), "Создаю запись...", async () => {
+      await api("/appointments", {
+        method: "POST",
+        body: JSON.stringify({
+          service_center_id: serviceCenterId,
+          vehicle_id: state.selectedCarId,
+          service_type: data.service_type,
+          service_name: bookingServiceName(data.service_type),
+          requested_start_at: data.slot,
+          customer_comment: data.customer_comment || null,
+        }),
+      });
+      await loadAppointments();
+      toast("Заявка отправлена в СТО");
+      haptic("success");
+    });
+  });
+  await reloadSlots();
   card.scrollIntoView({ behavior: "smooth", block: "start" });
 }
 
+function bookingServiceName(type) {
+  const names = {
+    oil_change: "Замена масла",
+    diagnostics: "Диагностика",
+    maintenance: "ТО",
+    tire_service: "Шиномонтаж",
+    brakes: "Тормоза",
+    repair: "Ремонт",
+    other: "Другое",
+  };
+  return names[type] || "Обслуживание";
+}
+
+function formatDateTime(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value).slice(0, 16).replace("T", " ");
+  return date.toLocaleString("ru-RU", { day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" });
+}
+
+async function loadServiceBookingSlots(serviceCenterId, form) {
+  const select = form.querySelector("#bookingSlotSelect");
+  const serviceType = form.querySelector('[name="service_type"]').value;
+  const date = form.querySelector('[name="date"]').value || today();
+  select.innerHTML = `<option value="">Загружаю...</option>`;
+  try {
+    const slots = await api(`/sto/${serviceCenterId}/available-slots?service_type=${encodeURIComponent(serviceType)}&date_from=${date}&date_to=${date}`);
+    select.innerHTML = slots.length
+      ? slots.map((slot) => `<option value="${slot.start_at}">${formatDateTime(slot.start_at)}</option>`).join("")
+      : `<option value="">Нет свободных окон</option>`;
+  } catch (error) {
+    select.innerHTML = `<option value="">Слоты не загрузились</option>`;
+  }
+}
+
+async function loadAppointments() {
+  const root = document.querySelector("#appointmentsList");
+  if (!root) return;
+  try {
+    state.appointments = await api("/appointments/my");
+    root.innerHTML = state.appointments.length
+      ? state.appointments.map((item) => `
+        <div class="stack-item">
+          <strong>${item.service_name}</strong>
+          <small>${formatDateTime(item.confirmed_start_at || item.proposed_start_at || item.requested_start_at)}</small>
+          <span class="trust-badge">${item.status}</span>
+          ${item.status === "proposed_new_time" ? `
+            <div class="service-actions">
+              <button type="button" data-accept-appointment="${item.id}">Принять время</button>
+              <button type="button" class="ghost-btn" data-reject-appointment="${item.id}">Отклонить</button>
+            </div>
+          ` : ""}
+        </div>
+      `).join("")
+      : `<div class="empty">Записей пока нет</div>`;
+    root.querySelectorAll("[data-accept-appointment]").forEach((button) => {
+      button.addEventListener("click", () => runAction(button, "Сохраняю...", async () => {
+        await api(`/appointments/${button.dataset.acceptAppointment}/accept-proposed-time`, { method: "POST" });
+        await loadAppointments();
+      }));
+    });
+    root.querySelectorAll("[data-reject-appointment]").forEach((button) => {
+      button.addEventListener("click", () => runAction(button, "Сохраняю...", async () => {
+        await api(`/appointments/${button.dataset.rejectAppointment}/reject-proposed-time`, {
+          method: "POST",
+          body: JSON.stringify({ comment: "Отклонено в Mini App" }),
+        });
+        await loadAppointments();
+      }));
+    });
+  } catch (error) {
+    root.innerHTML = `<div class="empty">Записи не загрузились</div>`;
+  }
+}
+
+async function loadMaintenanceRecommendations() {
+  const root = document.querySelector("#maintenanceRecommendations");
+  if (!root) return;
+  if (!state.selectedCarId) {
+    root.innerHTML = `<div class="empty">Выбери автомобиль</div>`;
+    return;
+  }
+  try {
+    state.maintenanceRecommendations = await api(`/vehicles/${state.selectedCarId}/maintenance-recommendations`);
+    root.innerHTML = state.maintenanceRecommendations.length
+      ? state.maintenanceRecommendations.map((item) => `
+        <div class="stack-item">
+          <strong>${item.title}</strong>
+          <small>${item.description || "Плановое обслуживание"}</small>
+          <small>${[item.due_odometer_km ? `${item.due_odometer_km} км` : "", item.due_date || ""].filter(Boolean).join(" · ")}</small>
+          <span class="trust-badge">${item.priority} · ${item.status}</span>
+          ${item.status === "active" ? `<button type="button" class="ghost-btn" data-dismiss-recommendation="${item.id}">Скрыть</button>` : ""}
+        </div>
+      `).join("")
+      : `<div class="empty">Рекомендаций пока нет</div>`;
+    root.querySelectorAll("[data-dismiss-recommendation]").forEach((button) => {
+      button.addEventListener("click", () => runAction(button, "Скрываю...", async () => {
+        await api(`/maintenance-recommendations/${button.dataset.dismissRecommendation}/dismiss`, { method: "POST" });
+        await loadMaintenanceRecommendations();
+      }));
+    });
+  } catch (error) {
+    root.innerHTML = `<div class="empty">Рекомендации не загрузились</div>`;
+  }
+}
+
+async function loadStoCalendar() {
+  const summary = document.querySelector("#stoDashboardSummary");
+  const list = document.querySelector("#stoCalendarList");
+  if (!summary || !list) return;
+  try {
+    if (!state.serviceCenters.length) {
+      const centers = await api("/service-centers/my");
+      state.serviceCenters = centers;
+    }
+    const center = state.serviceCenters[0];
+    if (!center) {
+      summary.innerHTML = "";
+      list.innerHTML = `<div class="empty">СТО пока не создано</div>`;
+      return;
+    }
+    const [dashboard, appointments] = await Promise.all([
+      api(`/sto/dashboard?service_center_id=${center.id}`),
+      api(`/sto/calendar?service_center_id=${center.id}`),
+    ]);
+    summary.innerHTML = `
+      <div class="stat-card"><span>Авто</span><strong>${dashboard.connected_vehicles}</strong></div>
+      <div class="stat-card"><span>Новые заявки</span><strong>${dashboard.pending_appointments}</strong></div>
+      <div class="stat-card"><span>Подтверждено</span><strong>${dashboard.confirmed_appointments}</strong></div>
+      <div class="stat-card"><span>Месяц</span><strong>${money(dashboard.revenue_month || 0)}</strong></div>
+    `;
+    list.innerHTML = appointments.length
+      ? appointments.map((item) => `
+        <div class="stack-item">
+          <strong>${item.service_name}</strong>
+          <small>${formatDateTime(item.confirmed_start_at || item.requested_start_at)} · авто #${item.vehicle_id}</small>
+          <span class="trust-badge">${item.status}</span>
+          ${item.status === "requested" ? `
+            <div class="service-actions">
+              <button type="button" data-confirm-sto-appointment="${item.id}">Подтвердить</button>
+              <button type="button" class="ghost-btn" data-reject-sto-appointment="${item.id}">Отклонить</button>
+            </div>
+          ` : ""}
+        </div>
+      `).join("")
+      : `<div class="empty">Записей на ближайший период нет</div>`;
+    list.querySelectorAll("[data-confirm-sto-appointment]").forEach((button) => {
+      button.addEventListener("click", () => runAction(button, "Подтверждаю...", async () => {
+        await api(`/sto/appointments/${button.dataset.confirmStoAppointment}/confirm`, {
+          method: "POST",
+          body: JSON.stringify({ comment: "Подтверждено в Mini App" }),
+        });
+        await loadStoCalendar();
+      }));
+    });
+    list.querySelectorAll("[data-reject-sto-appointment]").forEach((button) => {
+      button.addEventListener("click", () => runAction(button, "Отклоняю...", async () => {
+        await api(`/sto/appointments/${button.dataset.rejectStoAppointment}/reject`, {
+          method: "POST",
+          body: JSON.stringify({ comment: "Отклонено в Mini App" }),
+        });
+        await loadStoCalendar();
+      }));
+    });
+  } catch (error) {
+    summary.innerHTML = "";
+    list.innerHTML = `<div class="empty">Календарь СТО не загрузился</div>`;
+  }
+}
+
 function trustLabel(level) {
   const labels = {
     new_service: "Новый сервис",
@@ -2024,6 +2257,9 @@ async function openDrawerSection(sectionId, options = {}) {
   if (sectionId === "connectedServicesSection") await loadConnectedServices();
   if (sectionId === "servicePanelSection") await loadServiceCenters();
   if (sectionId === "publicServicesSection") await loadPublicServiceCenters();
+  if (sectionId === "appointmentsSection") await loadAppointments();
+  if (sectionId === "maintenanceRecommendationsSection") await loadMaintenanceRecommendations();
+  if (sectionId === "stoCalendarSection") await loadStoCalendar();
   if (sectionId === "reviewsSection") renderServiceReviews();
   if (sectionId === "adminSection") await loadAdminPendingServices();
   if (options.expenseCategory) {