Fix repositories

backend/app/models/house.py

@@ -1,8 +1,8 @@
 from sqlmodel import SQLModel, Field
-from uuid import uuid4
+from uuid import uuid4, UUID
 
 class House(SQLModel, table=True):
-    id: int = Field(primary_key=True, default_factory=uuid4),
+    id: UUID = Field(primary_key=True, default_factory=uuid4),
     address: str
     city: str
     country: str

backend/app/models/owner.py

@@ -1,8 +1,8 @@
 from sqlmodel import SQLModel, Field
-from uuid import uuid4
+from uuid import uuid4, UUID
 
 class Owner(SQLModel, table=True):
-    id: int = Field(default_factory=uuid4, primary_key=True)
+    id: UUID = Field(default_factory=uuid4, primary_key=True)
     name: str
     email: str
     # TODO add user_id

backend/app/models/user.py

@@ -1,7 +1,8 @@
 from sqlmodel import SQLModel, Field
+from uuid import uuid4, UUID
 
 class User(SQLModel, table=True):
-    id: int = Field(default=None, primary_key=True)
+    id: UUID = Field(default_factory=uuid4, primary_key=True)
     username: str = Field(unique=True, nullable=False)
     email: str = Field(unique=True, nullable=False)
     password_hash: str = Field(nullable=False)

backend/app/repositories/house_repository.py

@@ -1,30 +1,41 @@
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio.session import AsyncSession
-from app.models import House
+from typing import Annotated
+from fastapi import Depends
+from app.providers.db_provider import get_session
+from ..models.house import House
+from sqlmodel import select
+
+from uuid import UUID
 
 class HouseRepository:
-    def __init__(self, db: Session):
+    def __init__(self, session: Annotated[AsyncSession, Depends(get_session)]) -> None:
-        self.db = db
+        self.session = session
 
-    def get_all(self):
+    async def get_all(self) -> list[House]:
-        return self.db.query(House).all()
+        statement = select(House)
+        result = await self.session.execute(statement)
+        return result.scalars().all()
 
-    def get_by_id(self, house_id: int):
+    async def get_by_id(self, house_id: UUID):
-        return self.db.query(House).filter(House.id == house_id).first()
+        statement = select(House).where(House.id == house_id)
+        result = await self.session.execute(statement)
+        return result.scalar_one_or_none()
 
-    def create(self, house: House):
+    async def save(self, house: House) -> None:
-        self.db.add(house)
+        """
-        self.db.commit()
+        Save a house to the database. If a house with that ID already exists, do an upsert.
-        self.db.refresh(house)
+        """
-        return house
+        existing_house = await self.get_by_id(house.id)
+        if not existing_house:
+            existing_house = house
 
-    def update(self, house: House):
+        for key, value in house.model_dump(exclude_unset=True).items():
-        self.db.merge(house)
+            setattr(house, key, value)
-        self.db.commit()
-        return house
 
-    def delete(self, house_id: int):
+        try:
-        house = self.db.query(House).filter(House.id == house_id).first()
+            self.session.add(house)
-        if house:
+            await self.session.commit()
-            self.db.delete(house)
+            await self.session.refresh(house)
-            self.db.commit()
+        except Exception as e:
-        return house
+            await self.session.rollback()
+            raise e

backend/app/repositories/owner_repository.py

@@ -1,37 +1,36 @@
+from sqlalchemy.ext.asyncio.session import AsyncSession
+from typing import Annotated
+from fastapi import Depends
+from app.providers.db_provider import get_session
+from ..models.owner import Owner
+from sqlmodel import select
 
-from sqlalchemy.orm import Session
+from uuid import UUID
-from app.models.owner import Owner
-from app.schemas.owner import OwnerCreate, OwnerUpdate
 
 class OwnerRepository:
-    def __init__(self, db: Session):
+    def __init__(self, session: Annotated[AsyncSession, Depends(get_session)]) -> None:
-        self.db = db
+        self.session = session
 
-    def get(self, owner_id: int) -> Owner:
+    async def get_by_id(self, owner_id: UUID):
-        return self.db.query(Owner).filter(Owner.id == owner_id).first()
+        statement = select(Owner).where(Owner.id == owner_id)
+        result = await self.session.execute(statement)
+        return result.scalar_one_or_none()
 
-    def get_all(self, skip: int = 0, limit: int = 100) -> list[Owner]:
+    async def save(self, owner: Owner) -> None:
-        return self.db.query(Owner).offset(skip).limit(limit).all()
+        """
+        Save a owner to the database. If an owner with that ID already exists, do an upsert.
+        """
+        existing = await self.get_by_id(owner.id)
+        if not existing:
+            existing = owner
 
-    def create(self, owner: OwnerCreate) -> Owner:
+        for key, value in owner.model_dump(exclude_unset=True).items():
-        db_owner = Owner(**owner.dict())
+            setattr(owner, key, value)
-        self.db.add(db_owner)
-        self.db.commit()
-        self.db.refresh(db_owner)
-        return db_owner
 
-    def update(self, owner_id: int, owner: OwnerUpdate) -> Owner:
+        try:
-        db_owner = self.get(owner_id)
+            self.session.add(owner)
-        if db_owner:
+            await self.session.commit()
-            for key, value in owner.dict().items():
+            await self.session.refresh(owner)
-                setattr(db_owner, key, value)
+        except Exception as e:
-            self.db.commit()
+            await self.session.rollback()
-            self.db.refresh(db_owner)
+            raise e
-        return db_owner
-
-    def delete(self, owner_id: int) -> Owner:
-        db_owner = self.get(owner_id)
-        if db_owner:
-            self.db.delete(db_owner)
-            self.db.commit()
-        return db_owner

backend/app/repositories/user_repository.py

@@ -0,0 +1,36 @@
+from sqlalchemy.ext.asyncio.session import AsyncSession
+from typing import Annotated
+from fastapi import Depends
+from app.providers.db_provider import get_session
+from ..models.user import User
+from sqlmodel import select
+
+from uuid import UUID
+
+class UserRepository:
+    def __init__(self, session: Annotated[AsyncSession, Depends(get_session)]) -> None:
+        self.session = session
+
+    async def get_by_id(self, user_id: UUID):
+        statement = select(User).where(User.id == user_id)
+        result = await self.session.execute(statement)
+        return result.scalar_one_or_none()
+
+    async def save(self, user: User) -> None:
+        """
+        Save a user to the database. If a user with that ID already exists, do an upsert.
+        """
+        existing = await self.get_by_id(user.id)
+        if not existing:
+            existing = user
+
+        for key, value in user.model_dump(exclude_unset=True).items():
+            setattr(user, key, value)
+
+        try:
+            self.session.add(user)
+            await self.session.commit()
+            await self.session.refresh(user)
+        except Exception as e:
+            await self.session.rollback()
+            raise e