first

app/repositories/base.py

@@ -0,0 +1,243 @@
+from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union
+from sqlalchemy.orm import Session
+from sqlalchemy import func, and_, or_, desc, asc
+from app.models.base import BaseModel
+
+# Тип для модели SQLAlchemy
+ModelType = TypeVar("ModelType", bound=BaseModel)
+
+
+class BaseRepository(Generic[ModelType]):
+    """
+    Базовый репозиторий с CRUD операциями.
+    Использует Generic для поддержки разных моделей.
+    """
+
+    def __init__(self, db: Session, model: Type[ModelType]):
+        """
+        Инициализация репозитория
+
+        Args:
+            db: Сессия SQLAlchemy
+            model: Класс модели
+        """
+        self.db = db
+        self.model = model
+
+    def get_by_id(self, id: int) -> Optional[ModelType]:
+        """Получить запись по ID"""
+        return self.db.query(self.model).filter(self.model.id == id).first()
+
+    def get_by_uuid(self, uuid: str) -> Optional[ModelType]:
+        """Получить запись по UUID (если модель имеет поле uuid)"""
+        if hasattr(self.model, 'uuid'):
+            return self.db.query(self.model).filter(self.model.uuid == uuid).first()
+        raise AttributeError(f"Model {self.model.__name__} does not have 'uuid' field")
+
+    def get_all(
+            self,
+            skip: int = 0,
+            limit: int = 100,
+            order_by: Optional[str] = None,
+            descending: bool = False
+    ) -> List[ModelType]:
+        """Получить все записи с пагинацией"""
+        query = self.db.query(self.model)
+
+        if order_by and hasattr(self.model, order_by):
+            order_column = getattr(self.model, order_by)
+            if descending:
+                query = query.order_by(desc(order_column))
+            else:
+                query = query.order_by(asc(order_column))
+        elif hasattr(self.model, 'created_at'):
+            query = query.order_by(desc(self.model.created_at))
+
+        return query.offset(skip).limit(limit).all()
+
+    def create(self, obj_in: Dict[str, Any]) -> ModelType:
+        """Создать новую запись"""
+        db_obj = self.model(**obj_in)
+        self.db.add(db_obj)
+        self.db.commit()
+        self.db.refresh(db_obj)
+        return db_obj
+
+    def create_many(self, objects_in: List[Dict[str, Any]]) -> List[ModelType]:
+        """Создать несколько записей"""
+        db_objects = [self.model(**obj_in) for obj_in in objects_in]
+        self.db.add_all(db_objects)
+        self.db.commit()
+        for obj in db_objects:
+            self.db.refresh(obj)
+        return db_objects
+
+    def update(self, id: int, obj_in: Dict[str, Any]) -> Optional[ModelType]:
+        """Обновить запись"""
+        db_obj = self.get_by_id(id)
+        if not db_obj:
+            return None
+
+        for field, value in obj_in.items():
+            if hasattr(db_obj, field):
+                setattr(db_obj, field, value)
+
+        self.db.commit()
+        self.db.refresh(db_obj)
+        return db_obj
+
+    def update_by_uuid(self, uuid: str, obj_in: Dict[str, Any]) -> Optional[ModelType]:
+        """Обновить запись по UUID"""
+        db_obj = self.get_by_uuid(uuid)
+        if not db_obj:
+            return None
+
+        for field, value in obj_in.items():
+            if hasattr(db_obj, field):
+                setattr(db_obj, field, value)
+
+        self.db.commit()
+        self.db.refresh(db_obj)
+        return db_obj
+
+    def delete(self, id: int) -> bool:
+        """Удалить запись"""
+        db_obj = self.get_by_id(id)
+        if not db_obj:
+            return False
+
+        self.db.delete(db_obj)
+        self.db.commit()
+        return True
+
+    def delete_by_uuid(self, uuid: str) -> bool:
+        """Удалить запись по UUID"""
+        db_obj = self.get_by_uuid(uuid)
+        if not db_obj:
+            return False
+
+        self.db.delete(db_obj)
+        self.db.commit()
+        return True
+
+    def count(self, **filters) -> int:
+        """Подсчитать количество записей с фильтрами"""
+        query = self.db.query(self.model)
+
+        for field, value in filters.items():
+            if hasattr(self.model, field):
+                query = query.filter(getattr(self.model, field) == value)
+
+        return query.count()
+
+    def exists(self, **filters) -> bool:
+        """Проверить существование записи"""
+        return self.count(**filters) > 0
+
+    def filter_by(
+            self,
+            skip: int = 0,
+            limit: int = 100,
+            order_by: Optional[str] = None,
+            descending: bool = False,
+            **filters
+    ) -> List[ModelType]:
+        """Фильтрация записей по параметрам"""
+        query = self.db.query(self.model)
+
+        for field, value in filters.items():
+            if hasattr(self.model, field):
+                query = query.filter(getattr(self.model, field) == value)
+
+        if order_by and hasattr(self.model, order_by):
+            order_column = getattr(self.model, order_by)
+            if descending:
+                query = query.order_by(desc(order_column))
+            else:
+                query = query.order_by(asc(order_column))
+
+        return query.offset(skip).limit(limit).all()
+
+    def find_first(self, **filters) -> Optional[ModelType]:
+        """Найти первую запись по фильтрам"""
+        query = self.db.query(self.model)
+
+        for field, value in filters.items():
+            if hasattr(self.model, field):
+                query = query.filter(getattr(self.model, field) == value)
+
+        return query.first()
+
+    def bulk_update(self, ids: List[int], obj_in: Dict[str, Any]) -> int:
+        """Массовое обновление записей"""
+        updated_count = self.db.query(self.model).filter(
+            self.model.id.in_(ids)
+        ).update(obj_in, synchronize_session=False)
+
+        self.db.commit()
+        return updated_count
+
+    def bulk_delete(self, ids: List[int]) -> int:
+        """Массовое удаление записей"""
+        deleted_count = self.db.query(self.model).filter(
+            self.model.id.in_(ids)
+        ).delete(synchronize_session=False)
+
+        self.db.commit()
+        return deleted_count
+
+    def get_or_create(self, defaults: Optional[Dict] = None, **filters) -> tuple[ModelType, bool]:
+        """
+        Получить запись или создать новую
+
+        Returns:
+            tuple: (объект, создан_ли_новый)
+        """
+        instance = self.find_first(**filters)
+
+        if instance:
+            return instance, False
+
+        if defaults:
+            filters.update(defaults)
+
+        return self.create(filters), True
+
+    def paginate(
+            self,
+            page: int = 1,
+            per_page: int = 20,
+            order_by: Optional[str] = None,
+            descending: bool = False,
+            **filters
+    ) -> Dict[str, Any]:
+        """
+        Пагинированный список записей
+
+        Returns:
+            Dict с ключами: items, total, page, per_page, pages
+        """
+        query = self.db.query(self.model)
+
+        for field, value in filters.items():
+            if hasattr(self.model, field):
+                query = query.filter(getattr(self.model, field) == value)
+
+        total = query.count()
+
+        if order_by and hasattr(self.model, order_by):
+            order_column = getattr(self.model, order_by)
+            if descending:
+                query = query.order_by(desc(order_column))
+            else:
+                query = query.order_by(asc(order_column))
+
+        items = query.offset((page - 1) * per_page).limit(per_page).all()
+
+        return {
+            "items": items,
+            "total": total,
+            "page": page,
+            "per_page": per_page,
+            "pages": (total + per_page - 1) // per_page
+        }