Enhance Telegram bot with database integration and API features

- Added SQLite database support with Alembic for migrations.
- Implemented FastAPI for HTTP API to manage duties.
- Updated configuration to include database URL and HTTP port.
- Created entrypoint script for Docker to handle migrations and permissions.
- Expanded command handlers to register users and display duties.
- Developed a web application for calendar display of duties.
- Included necessary Pydantic schemas and SQLAlchemy models for data handling.
- Updated requirements.txt to include new dependencies for FastAPI and SQLAlchemy.

db/__init__.py

@@ -0,0 +1,11 @@
+"""Database layer: SQLAlchemy models, Pydantic schemas, repository, init."""
+from db.models import Base, User, Duty
+from db.schemas import UserCreate, UserInDb, DutyCreate, DutyInDb, DutyWithUser
+from db.session import get_engine, get_session_factory, get_session
+from db.repository import get_or_create_user, get_duties, insert_duty
+
+
+def init_db(database_url: str) -> None:
+    """Create tables from metadata (Alembic migrations handle schema in production)."""
+    engine = get_engine(database_url)
+    Base.metadata.create_all(bind=engine)

db/models.py

@@ -0,0 +1,32 @@
+"""SQLAlchemy ORM models for users and duties."""
+from sqlalchemy import ForeignKey, Integer, BigInteger, Text
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    """Declarative base for all models."""
+    pass
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    telegram_user_id: Mapped[int] = mapped_column(BigInteger, unique=True, nullable=False)
+    full_name: Mapped[str] = mapped_column(Text, nullable=False)
+    username: Mapped[str | None] = mapped_column(Text, nullable=True)
+    first_name: Mapped[str | None] = mapped_column(Text, nullable=True)
+    last_name: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    duties: Mapped[list["Duty"]] = relationship("Duty", back_populates="user")
+
+
+class Duty(Base):
+    __tablename__ = "duties"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("users.id"), nullable=False)
+    start_at: Mapped[str] = mapped_column(Text, nullable=False)  # ISO 8601
+    end_at: Mapped[str] = mapped_column(Text, nullable=False)  # ISO 8601
+
+    user: Mapped["User"] = relationship("User", back_populates="duties")

db/repository.py

@@ -0,0 +1,61 @@
+"""Repository: get_or_create_user, get_duties, insert_duty."""
+from sqlalchemy.orm import Session
+
+from db.models import User, Duty
+
+
+def get_or_create_user(
+    session: Session,
+    telegram_user_id: int,
+    full_name: str,
+    username: str | None = None,
+    first_name: str | None = None,
+    last_name: str | None = None,
+) -> User:
+    user = session.query(User).filter(User.telegram_user_id == telegram_user_id).first()
+    if user:
+        user.full_name = full_name
+        user.username = username
+        user.first_name = first_name
+        user.last_name = last_name
+        session.commit()
+        session.refresh(user)
+        return user
+    user = User(
+        telegram_user_id=telegram_user_id,
+        full_name=full_name,
+        username=username,
+        first_name=first_name,
+        last_name=last_name,
+    )
+    session.add(user)
+    session.commit()
+    session.refresh(user)
+    return user
+
+
+def get_duties(
+    session: Session,
+    from_date: str,
+    to_date: str,
+) -> list[tuple[Duty, str]]:
+    """Return list of (Duty, full_name) overlapping the given date range (ISO date strings)."""
+    q = (
+        session.query(Duty, User.full_name)
+        .join(User, Duty.user_id == User.id)
+        .filter(Duty.start_at <= to_date, Duty.end_at >= from_date)
+    )
+    return list(q.all())
+
+
+def insert_duty(
+    session: Session,
+    user_id: int,
+    start_at: str,
+    end_at: str,
+) -> Duty:
+    duty = Duty(user_id=user_id, start_at=start_at, end_at=end_at)
+    session.add(duty)
+    session.commit()
+    session.refresh(duty)
+    return duty

db/schemas.py

@@ -0,0 +1,43 @@
+"""Pydantic schemas for API and validation."""
+from pydantic import BaseModel, ConfigDict
+
+
+class UserBase(BaseModel):
+    full_name: str
+    username: str | None = None
+    first_name: str | None = None
+    last_name: str | None = None
+
+
+class UserCreate(UserBase):
+    telegram_user_id: int
+
+
+class UserInDb(UserBase):
+    id: int
+    telegram_user_id: int
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class DutyBase(BaseModel):
+    user_id: int
+    start_at: str  # ISO 8601
+    end_at: str    # ISO 8601
+
+
+class DutyCreate(DutyBase):
+    pass
+
+
+class DutyInDb(DutyBase):
+    id: int
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class DutyWithUser(DutyInDb):
+    """Duty with full_name for calendar display."""
+    full_name: str
+
+    model_config = ConfigDict(from_attributes=True)

db/session.py

@@ -0,0 +1,31 @@
+"""SQLAlchemy engine and session factory."""
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from db.models import Base
+
+_engine = None
+_SessionLocal = None
+
+
+def get_engine(database_url: str):
+    global _engine
+    if _engine is None:
+        _engine = create_engine(
+            database_url,
+            connect_args={"check_same_thread": False} if "sqlite" in database_url else {},
+            echo=False,
+        )
+    return _engine
+
+
+def get_session_factory(database_url: str) -> sessionmaker[Session]:
+    global _SessionLocal
+    if _SessionLocal is None:
+        engine = get_engine(database_url)
+        _SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    return _SessionLocal
+
+
+def get_session(database_url: str) -> Session:
+    return get_session_factory(database_url)()