Slot-Me.ru — Платформа бронирования встреч

src/
├── app/          # Инициализация (Router, Query, Theme)
├── pages/        # 18 страниц (home, auth, bookings, profile...)
├── widgets/      # Лейауты (MainLayout, DashboardLayout)
├── entities/     # 9 бизнес-сущностей (user, booking, availability...)
└── shared/       # UI компоненты, API клиенты, утилиты

# Модель availability: рекуррентное расписание
class Availability(Base):
    day_of_week = Column(Integer)  # 0 = Monday
    start_time = Column(Time)
    end_time = Column(Time)
    event_type_id = Column(ForeignKey)
 
# Модель date_override: блокировка конкретных дат
class DateOverride(Base):
    date = Column(Date)
    is_available = Column(Boolean)
    title = Column(String)  # "Отпуск", "Конференция"

# Сервис синхронизации
async def sync_booking_to_calendar(booking: Booking):
    """Создаёт событие в подключенных календарях"""
    integrations = await get_user_integrations(booking.user_id)
 
    for integration in integrations:
        if integration.provider == "google":
            await google_calendar_service.create_event(
                calendar_id=integration.calendar_id,
                event=booking_to_event(booking)
            )
        elif integration.provider == "yandex":
            await yandex_calendar_service.create_event(
                calendar_id=integration.calendar_id,
                event=booking_to_event(booking)
            )

# APScheduler для напоминаний
scheduler = AsyncIOScheduler()
 
@scheduler.scheduled_job("interval", minutes=5)
async def send_reminders():
    """Отправляет напоминания о предстоящих встречах"""
    upcoming = await get_upcoming_bookings(
        time_range=(now(), now() + timedelta(minutes=20))
    )
 
    for booking in upcoming:
        await email_service.send_reminder(booking)

@router.get("/auth/google/auth")
async def google_auth():
    """Редирект на Google OAuth"""
    return RedirectResponse(
        f"https://accounts.google.com/o/oauth2/v2/auth"
        f"?client_id={settings.GOOGLE_CLIENT_ID}"
        f"&redirect_uri={settings.GOOGLE_REDIRECT_URI}"
        f"&scope=openid email profile"
    )
 
@router.get("/auth/google/callback")
async def google_callback(code: str):
    """Обмен кода на токен, создание/логин пользователя"""
    # Получаем токен от Google
    token = await exchange_code_for_token(code)
    # Получаем профиль
    profile = await get_google_profile(token)
    # Создаём/находим пользователя
    user = await get_or_create_user(email=profile.email)
    # Возвращаем JWT
    return {"access_token": create_jwt(user), ...}

pytest
# 196 passed, 56.33% coverage

import logfire
 
# Автоматическая инструментация
logfire.configure()
logfire.instrument_fastapi(app)
logfire.instrument_sqlalchemy(engine)
logfire.instrument_redis()
 
# Ручное логирование
with logfire.span("calculate_available_slots"):
    slots = calculate_slots(user_id, date_range)
    logfire.info("Slots calculated", count=len(slots))

# .gitlab-ci.yml
stages:
  - test
  - build
  - deploy
 
test:
  script:
    - pytest --cov=app --cov-report=term
    - npm run lint
    - npm run type-check
 
deploy:
  only: [main]
  script:
    - docker build -t slotme:latest .
    - docker-compose up -d --no-deps --build
    - docker exec slotme alembic upgrade head

async def calculate_available_slots(
    user_id: str,
    event_type_id: str,
    date_range: DateRange
) -> List[TimeSlot]:
    """Генерирует список свободных слотов"""
    # 1. Получаем расписание пользователя
    availabilities = await get_availabilities(user_id, event_type_id)
 
    # 2. Получаем блокировки
    overrides = await get_date_overrides(user_id, date_range)
 
    # 3. Получаем существующие бронирования
    bookings = await get_bookings(user_id, date_range)
 
    # 4. Получаем занятость из календарей
    busy_times = await get_calendar_busy_times(user_id, date_range)
 
    # 5. Генерируем потенциальные слоты
    potential_slots = generate_slots_from_availability(
        availabilities, date_range
    )
 
    # 6. Фильтруем занятые слоты
    return filter_available_slots(
        potential_slots,
        overrides,
        bookings,
        busy_times
    )

# Модель
booking.start_time  # datetime в UTC
 
# API response
{
  "start_time": "2025-10-24T10:00:00Z",  # ISO 8601 UTC
  "timezone": "Europe/Moscow"
}
 
# Frontend конвертирует в локальный timezone
const localTime = parseISO(booking.start_time)
  .toLocaleString(undefined, { timeZone: user.timezone })

@router.post("/bookings")
async def create_booking(
    request: BookingCreate,
    idempotency_key: str = Header(None)
):
    if idempotency_key:
        # Проверяем, создавали ли уже с этим ключом
        cached = await redis.get(f"idempotency:{idempotency_key}")
        if cached:
            return JSONResponse(cached, status_code=200)
 
    # Создаём бронирование
    booking = await booking_service.create(request)
 
    if idempotency_key:
        # Кэшируем результат на 24 часа
        await redis.setex(
            f"idempotency:{idempotency_key}",
            86400,
            booking.json()
        )
 
    return booking