Refactoring code for modular approach

app/services/admin_service.py

@@ -0,0 +1,193 @@
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from fastapi import HTTPException
+from datetime import datetime
+import logging
+from typing import List, Optional, Tuple
+
+from models.database_models import User, MarketplaceImportJob, Shop
+from models.api_models import MarketplaceImportJobResponse
+
+logger = logging.getLogger(__name__)
+
+
+class AdminService:
+    """Service class for admin operations following the application's service pattern"""
+
+    def get_all_users(self, db: Session, skip: int = 0, limit: int = 100) -> List[User]:
+        """Get paginated list of all users"""
+        return db.query(User).offset(skip).limit(limit).all()
+
+    def toggle_user_status(self, db: Session, user_id: int, current_admin_id: int) -> Tuple[User, str]:
+        """
+        Toggle user active status
+
+        Args:
+            db: Database session
+            user_id: ID of user to toggle
+            current_admin_id: ID of the admin performing the action
+
+        Returns:
+            Tuple of (updated_user, status_message)
+
+        Raises:
+            HTTPException: If user not found or trying to deactivate own account
+        """
+        user = db.query(User).filter(User.id == user_id).first()
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+
+        if user.id == current_admin_id:
+            raise HTTPException(status_code=400, detail="Cannot deactivate your own account")
+
+        user.is_active = not user.is_active
+        user.updated_at = datetime.utcnow()
+        db.commit()
+        db.refresh(user)
+
+        status = "activated" if user.is_active else "deactivated"
+        logger.info(f"User {user.username} has been {status} by admin {current_admin_id}")
+        return user, f"User {user.username} has been {status}"
+
+    def get_all_shops(self, db: Session, skip: int = 0, limit: int = 100) -> Tuple[List[Shop], int]:
+        """
+        Get paginated list of all shops with total count
+
+        Args:
+            db: Database session
+            skip: Number of records to skip
+            limit: Maximum number of records to return
+
+        Returns:
+            Tuple of (shops_list, total_count)
+        """
+        total = db.query(Shop).count()
+        shops = db.query(Shop).offset(skip).limit(limit).all()
+        return shops, total
+
+    def verify_shop(self, db: Session, shop_id: int) -> Tuple[Shop, str]:
+        """
+        Toggle shop verification status
+
+        Args:
+            db: Database session
+            shop_id: ID of shop to verify/unverify
+
+        Returns:
+            Tuple of (updated_shop, status_message)
+
+        Raises:
+            HTTPException: If shop not found
+        """
+        shop = db.query(Shop).filter(Shop.id == shop_id).first()
+        if not shop:
+            raise HTTPException(status_code=404, detail="Shop not found")
+
+        shop.is_verified = not shop.is_verified
+        shop.updated_at = datetime.utcnow()
+        db.commit()
+        db.refresh(shop)
+
+        status = "verified" if shop.is_verified else "unverified"
+        logger.info(f"Shop {shop.shop_code} has been {status}")
+        return shop, f"Shop {shop.shop_code} has been {status}"
+
+    def toggle_shop_status(self, db: Session, shop_id: int) -> Tuple[Shop, str]:
+        """
+        Toggle shop active status
+
+        Args:
+            db: Database session
+            shop_id: ID of shop to activate/deactivate
+
+        Returns:
+            Tuple of (updated_shop, status_message)
+
+        Raises:
+            HTTPException: If shop not found
+        """
+        shop = db.query(Shop).filter(Shop.id == shop_id).first()
+        if not shop:
+            raise HTTPException(status_code=404, detail="Shop not found")
+
+        shop.is_active = not shop.is_active
+        shop.updated_at = datetime.utcnow()
+        db.commit()
+        db.refresh(shop)
+
+        status = "activated" if shop.is_active else "deactivated"
+        logger.info(f"Shop {shop.shop_code} has been {status}")
+        return shop, f"Shop {shop.shop_code} has been {status}"
+
+    def get_marketplace_import_jobs(
+            self,
+            db: Session,
+            marketplace: Optional[str] = None,
+            shop_name: Optional[str] = None,
+            status: Optional[str] = None,
+            skip: int = 0,
+            limit: int = 100
+    ) -> List[MarketplaceImportJobResponse]:
+        """
+        Get filtered and paginated marketplace import jobs
+
+        Args:
+            db: Database session
+            marketplace: Filter by marketplace name (case-insensitive partial match)
+            shop_name: Filter by shop name (case-insensitive partial match)
+            status: Filter by exact status
+            skip: Number of records to skip
+            limit: Maximum number of records to return
+
+        Returns:
+            List of MarketplaceImportJobResponse objects
+        """
+        query = db.query(MarketplaceImportJob)
+
+        # Apply filters
+        if marketplace:
+            query = query.filter(MarketplaceImportJob.marketplace.ilike(f"%{marketplace}%"))
+        if shop_name:
+            query = query.filter(MarketplaceImportJob.shop_name.ilike(f"%{shop_name}%"))
+        if status:
+            query = query.filter(MarketplaceImportJob.status == status)
+
+        # Order by creation date and apply pagination
+        jobs = query.order_by(MarketplaceImportJob.created_at.desc()).offset(skip).limit(limit).all()
+
+        return [
+            MarketplaceImportJobResponse(
+                job_id=job.id,
+                status=job.status,
+                marketplace=job.marketplace,
+                shop_name=job.shop_name,
+                imported=job.imported_count or 0,
+                updated=job.updated_count or 0,
+                total_processed=job.total_processed or 0,
+                error_count=job.error_count or 0,
+                error_message=job.error_message,
+                created_at=job.created_at,
+                started_at=job.started_at,
+                completed_at=job.completed_at
+            ) for job in jobs
+        ]
+
+    def get_user_by_id(self, db: Session, user_id: int) -> Optional[User]:
+        """Get user by ID"""
+        return db.query(User).filter(User.id == user_id).first()
+
+    def get_shop_by_id(self, db: Session, shop_id: int) -> Optional[Shop]:
+        """Get shop by ID"""
+        return db.query(Shop).filter(Shop.id == shop_id).first()
+
+    def user_exists(self, db: Session, user_id: int) -> bool:
+        """Check if user exists by ID"""
+        return db.query(User).filter(User.id == user_id).first() is not None
+
+    def shop_exists(self, db: Session, shop_id: int) -> bool:
+        """Check if shop exists by ID"""
+        return db.query(Shop).filter(Shop.id == shop_id).first() is not None
+
+
+# Create service instance following the same pattern as product_service
+admin_service = AdminService()