Initial commit

src/trudex/infrastructure/database/dao/group.py

@@ -0,0 +1,73 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from trudex.domain.schemas import Group as DomainGroup
+from trudex.infrastructure.database.dto.group import GroupDTO
+from trudex.infrastructure.database.models import Group
+
+
+class GroupDAO:
+    def __init__(self, session: AsyncSession) -> None:
+        self.session: AsyncSession = session
+    
+    async def get_by_id(self, group_id: int) -> DomainGroup | None:
+        result = await self.session.execute(
+            select(Group).where(Group.id == group_id)
+        )
+        model = result.scalar_one_or_none()
+        return GroupDTO(model).to_domain() if model else None
+    
+    async def get_by_number(self, number: int) -> DomainGroup | None:
+        result = await self.session.execute(
+            select(Group).where(Group.number == number)
+        )
+        model = result.scalar_one_or_none()
+        return GroupDTO(model).to_domain() if model else None
+    
+    async def get_all(self) -> list[DomainGroup]:
+        result = await self.session.execute(select(Group))
+        models = list(result.scalars().all())
+        return [GroupDTO(model).to_domain() for model in models]
+    
+    async def create(
+        self,
+        number: int,
+    ) -> DomainGroup:
+        group = Group(
+            number=number,
+        )
+        self.session.add(group)
+        await self.session.flush()
+        await self.session.refresh(group)
+        return GroupDTO(group).to_domain()
+    
+    async def update(
+        self,
+        group_id: int,
+        number: int | None = None
+    ) -> DomainGroup | None:
+        result = await self.session.execute(
+            select(Group).where(Group.id == group_id)
+        )
+        group = result.scalar_one_or_none()
+        if not group:
+            return None
+        
+        if number is not None:
+            group.number = number
+        
+        await self.session.flush()
+        await self.session.refresh(group)
+        return GroupDTO(group).to_domain()
+    
+    async def delete(self, group_id: int) -> bool:
+        result = await self.session.execute(
+            select(Group).where(Group.id == group_id)
+        )
+        group = result.scalar_one_or_none()
+        if not group:
+            return False
+        
+        await self.session.delete(group)
+        await self.session.flush()
+        return True

src/trudex/infrastructure/database/dto/group.py

@@ -0,0 +1,15 @@
+from trudex.domain.schemas import Group as DomainGroup
+from trudex.infrastructure.database.models import Group as GroupModel
+
+
+class GroupDTO:
+    def __init__(self, model: GroupModel) -> None:
+        self.model: GroupModel = model
+    
+    def to_domain(self) -> DomainGroup:
+        return DomainGroup(
+            id=self.model.id,
+            number=self.model.number,
+            created_at=self.model.created_at,
+            updated_at=self.model.updated_at,
+        )

src/trudex/infrastructure/database/models.py

@@ -24,6 +24,23 @@ class User(Base):
     updated_at: Mapped[datetime] = mapped_column(server_default=func.now(), onupdate=func.now())
 
 
+@final
+class Group(Base):
+    __tablename__ = "groups"
+    
+    id: Mapped[int] = mapped_column(primary_key=True)
+    number: Mapped[int] = mapped_column(Integer, unique=True, index=True)
+    created_at: Mapped[datetime] = mapped_column(server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(server_default=func.now(), onupdate=func.now())
+    
+    __table_args__ = (
+        CheckConstraint("number >= 1000 AND number <= 9999", name="check_group_number"),
+    )
+    __table_args__ = (
+        CheckConstraint("number >= 1000 AND number <= 9999", name="check_group_number"),
+    )
+
+
 class QuestionType(str, Enum):
     SINGLE = "single"
     MULTIPLE = "multiple"