# app/services/admin_service.py """ Admin service for managing users, vendors, and import jobs. This module provides classes and functions for: - User management and status control - Vendor verification and activation - Marketplace import job monitoring """ import logging from datetime import datetime, timezone from typing import List, Optional, Tuple from sqlalchemy.orm import Session from app.exceptions import ( UserNotFoundException, UserStatusChangeException, CannotModifySelfException, VendorNotFoundException, VendorVerificationException, AdminOperationException, ) from models.schemas.marketplace_import_job import MarketplaceImportJobResponse from models.database.marketplace_import_job import MarketplaceImportJob from models.database.vendor import Vendor from models.database.user import User 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.""" try: return db.query(User).offset(skip).limit(limit).all() except Exception as e: logger.error(f"Failed to retrieve users: {str(e)}") raise AdminOperationException( operation="get_all_users", reason="Database query failed" ) 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: UserNotFoundException: If user not found CannotModifySelfException: If trying to modify own account UserStatusChangeException: If status change is not allowed """ user = self._get_user_by_id_or_raise(db, user_id) # Prevent self-modification if user.id == current_admin_id: raise CannotModifySelfException(user_id, "deactivate account") # Check if user is another admin - FIXED LOGIC if user.role == "admin" and user.id != current_admin_id: raise UserStatusChangeException( user_id=user_id, current_status="admin", attempted_action="toggle status", reason="Cannot modify another admin user" ) try: original_status = user.is_active user.is_active = not user.is_active user.updated_at = datetime.now(timezone.utc) db.commit() db.refresh(user) status_action = "activated" if user.is_active else "deactivated" message = f"User {user.username} has been {status_action}" logger.info(f"{message} by admin {current_admin_id}") return user, message except Exception as e: db.rollback() logger.error(f"Failed to toggle user {user_id} status: {str(e)}") raise UserStatusChangeException( user_id=user_id, current_status="active" if original_status else "inactive", attempted_action="toggle status", reason="Database update failed" ) def get_all_vendors( self, db: Session, skip: int = 0, limit: int = 100 ) -> Tuple[List[Vendor], int]: """ Get paginated list of all vendors with total count. Args: db: Database session skip: Number of records to skip limit: Maximum number of records to return Returns: Tuple of (vendors_list, total_count) """ try: total = db.query(Vendor).count() vendors =db.query(Vendor).offset(skip).limit(limit).all() return vendors, total except Exception as e: logger.error(f"Failed to retrieve vendors: {str(e)}") raise AdminOperationException( operation="get_all_vendors", reason="Database query failed" ) def verify_vendor(self, db: Session, vendor_id: int) -> Tuple[Vendor, str]: """ Toggle vendor verification status. Args: db: Database session vendor_id: ID of vendor to verify/unverify Returns: Tuple of (updated_vendor, status_message) Raises: VendorNotFoundException: If vendor not found VendorVerificationException: If verification fails """ vendor = self._get_vendor_by_id_or_raise(db, vendor_id) try: original_status = vendor.is_verified vendor.is_verified = not vendor.is_verified vendor.updated_at = datetime.now(timezone.utc) # Add verification timestamp if implementing audit trail if vendor.is_verified: vendor.verified_at = datetime.now(timezone.utc) db.commit() db.refresh(vendor) status_action = "verified" if vendor.is_verified else "unverified" message = f"Vendor {vendor.vendor_code} has been {status_action}" logger.info(message) return vendor, message except Exception as e: db.rollback() logger.error(f"Failed to verify vendor {vendor_id}: {str(e)}") raise VendorVerificationException( vendor_id=vendor_id, reason="Database update failed", current_verification_status=original_status ) def toggle_vendor_status(self, db: Session, vendor_id: int) -> Tuple[Vendor, str]: """ Toggle vendor active status. Args: db: Database session vendor_id: ID of vendor to activate/deactivate Returns: Tuple of (updated_vendor, status_message) Raises: VendorNotFoundException: If vendor not found AdminOperationException: If status change fails """ vendor = self._get_vendor_by_id_or_raise(db, vendor_id) try: original_status = vendor.is_active vendor.is_active = not vendor.is_active vendor.updated_at = datetime.now(timezone.utc) db.commit() db.refresh(vendor) status_action = "activated" if vendor.is_active else "deactivated" message = f"Vendor {vendor.vendor_code} has been {status_action}" logger.info(message) return vendor , message except Exception as e: db.rollback() logger.error(f"Failed to toggle vendor {vendor_id} status: {str(e)}") raise AdminOperationException( operation="toggle_vendor_status", reason="Database update failed", target_type="vendor ", target_id=str(vendor_id) ) def get_marketplace_import_jobs( self, db: Session, marketplace: Optional[str] = None, vendor_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) vendor_name: Filter by vendor 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 """ try: query = db.query(MarketplaceImportJob) # Apply filters if marketplace: query = query.filter( MarketplaceImportJob.marketplace.ilike(f"%{marketplace}%") ) if vendor_name: query = query.filter(MarketplaceImportJob.vendor_name.ilike(f"%{vendor_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 [self._convert_job_to_response(job) for job in jobs] except Exception as e: logger.error(f"Failed to retrieve marketplace import jobs: {str(e)}") raise AdminOperationException( operation="get_marketplace_import_jobs", reason="Database query failed" ) def get_user_statistics(self, db: Session) -> dict: """Get user statistics for admin dashboard.""" try: total_users = db.query(User).count() active_users = db.query(User).filter(User.is_active == True).count() inactive_users = total_users - active_users return { "total_users": total_users, "active_users": active_users, "inactive_users": inactive_users, "activation_rate": (active_users / total_users * 100) if total_users > 0 else 0 } except Exception as e: logger.error(f"Failed to get user statistics: {str(e)}") raise AdminOperationException( operation="get_user_statistics", reason="Database query failed" ) def get_vendor_statistics(self, db: Session) -> dict: """Get vendor statistics for admin dashboard.""" try: total_vendors = db.query(Vendor).count() active_vendors = db.query(Vendor).filter(Vendor.is_active == True).count() verified_vendors = db.query(Vendor).filter(Vendor.is_verified == True).count() return { "total_vendors": total_vendors, "active_vendors": active_vendors, "verified_vendors": verified_vendors, "verification_rate": (verified_vendors / total_vendors * 100) if total_vendors > 0 else 0 } except Exception as e: logger.error(f"Failed to get vendor statistics: {str(e)}") raise AdminOperationException( operation="get_vendor_statistics", reason="Database query failed" ) # Private helper methods def _get_user_by_id_or_raise(self, db: Session, user_id: int) -> User: """Get user by ID or raise UserNotFoundException.""" user = db.query(User).filter(User.id == user_id).first() if not user: raise UserNotFoundException(str(user_id)) return user def _get_vendor_by_id_or_raise(self, db: Session, vendor_id: int) -> Vendor: """Get vendor by ID or raise VendorNotFoundException.""" vendor = db.query(Vendor).filter(Vendor.id == vendor_id).first() if not vendor : raise VendorNotFoundException(str(vendor_id), identifier_type="id") return vendor def _convert_job_to_response(self, job: MarketplaceImportJob) -> MarketplaceImportJobResponse: """Convert database model to response schema.""" return MarketplaceImportJobResponse( job_id=job.id, status=job.status, marketplace=job.marketplace, vendor_id=job.vendor.id if job.vendor else None, vendor_code=job.vendor.vendor_code if job.vendor else None, vendor_name=job.vendor_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, ) # Create service instance following the same pattern as marketplace_product_service admin_service = AdminService()