364 lines
13 KiB
Python
364 lines
13 KiB
Python
# app/services/admin_service.py
|
|
"""
|
|
Admin service for managing users, shops, and import jobs.
|
|
|
|
This module provides classes and functions for:
|
|
- User management and status control
|
|
- Shop 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,
|
|
ShopNotFoundException,
|
|
ShopVerificationException,
|
|
AdminOperationException,
|
|
)
|
|
from models.schemas.marketplace import MarketplaceImportJobResponse
|
|
from models.database.marketplace import MarketplaceImportJob
|
|
from models.database.shop import Shop
|
|
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_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)
|
|
"""
|
|
try:
|
|
total = db.query(Shop).count()
|
|
shops = db.query(Shop).offset(skip).limit(limit).all()
|
|
return shops, total
|
|
except Exception as e:
|
|
logger.error(f"Failed to retrieve shops: {str(e)}")
|
|
raise AdminOperationException(
|
|
operation="get_all_shops",
|
|
reason="Database query failed"
|
|
)
|
|
|
|
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:
|
|
ShopNotFoundException: If shop not found
|
|
ShopVerificationException: If verification fails
|
|
"""
|
|
shop = self._get_shop_by_id_or_raise(db, shop_id)
|
|
|
|
try:
|
|
original_status = shop.is_verified
|
|
shop.is_verified = not shop.is_verified
|
|
shop.updated_at = datetime.now(timezone.utc)
|
|
|
|
# Add verification timestamp if implementing audit trail
|
|
if shop.is_verified:
|
|
shop.verified_at = datetime.now(timezone.utc)
|
|
|
|
db.commit()
|
|
db.refresh(shop)
|
|
|
|
status_action = "verified" if shop.is_verified else "unverified"
|
|
message = f"Shop {shop.shop_code} has been {status_action}"
|
|
|
|
logger.info(message)
|
|
return shop, message
|
|
|
|
except Exception as e:
|
|
db.rollback()
|
|
logger.error(f"Failed to verify shop {shop_id}: {str(e)}")
|
|
raise ShopVerificationException(
|
|
shop_id=shop_id,
|
|
reason="Database update failed",
|
|
current_verification_status=original_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:
|
|
ShopNotFoundException: If shop not found
|
|
AdminOperationException: If status change fails
|
|
"""
|
|
shop = self._get_shop_by_id_or_raise(db, shop_id)
|
|
|
|
try:
|
|
original_status = shop.is_active
|
|
shop.is_active = not shop.is_active
|
|
shop.updated_at = datetime.now(timezone.utc)
|
|
db.commit()
|
|
db.refresh(shop)
|
|
|
|
status_action = "activated" if shop.is_active else "deactivated"
|
|
message = f"Shop {shop.shop_code} has been {status_action}"
|
|
|
|
logger.info(message)
|
|
return shop, message
|
|
|
|
except Exception as e:
|
|
db.rollback()
|
|
logger.error(f"Failed to toggle shop {shop_id} status: {str(e)}")
|
|
raise AdminOperationException(
|
|
operation="toggle_shop_status",
|
|
reason="Database update failed",
|
|
target_type="shop",
|
|
target_id=str(shop_id)
|
|
)
|
|
|
|
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
|
|
"""
|
|
try:
|
|
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 [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_shop_statistics(self, db: Session) -> dict:
|
|
"""Get shop statistics for admin dashboard."""
|
|
try:
|
|
total_shops = db.query(Shop).count()
|
|
active_shops = db.query(Shop).filter(Shop.is_active == True).count()
|
|
verified_shops = db.query(Shop).filter(Shop.is_verified == True).count()
|
|
|
|
return {
|
|
"total_shops": total_shops,
|
|
"active_shops": active_shops,
|
|
"verified_shops": verified_shops,
|
|
"verification_rate": (verified_shops / total_shops * 100) if total_shops > 0 else 0
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Failed to get shop statistics: {str(e)}")
|
|
raise AdminOperationException(
|
|
operation="get_shop_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_shop_by_id_or_raise(self, db: Session, shop_id: int) -> Shop:
|
|
"""Get shop by ID or raise ShopNotFoundException."""
|
|
shop = db.query(Shop).filter(Shop.id == shop_id).first()
|
|
if not shop:
|
|
raise ShopNotFoundException(str(shop_id), identifier_type="id")
|
|
return shop
|
|
|
|
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,
|
|
shop_id=job.shop.id if job.shop else None,
|
|
shop_code=job.shop.shop_code if job.shop else None,
|
|
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,
|
|
)
|
|
|
|
# Legacy methods for backward compatibility (mark as deprecated)
|
|
def get_user_by_id(self, db: Session, user_id: int) -> Optional[User]:
|
|
"""Get user by ID. DEPRECATED: Use _get_user_by_id_or_raise instead."""
|
|
logger.warning("get_user_by_id is deprecated, use proper exception handling")
|
|
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. DEPRECATED: Use _get_shop_by_id_or_raise instead."""
|
|
logger.warning("get_shop_by_id is deprecated, use proper exception handling")
|
|
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. DEPRECATED: Use proper exception handling."""
|
|
logger.warning("user_exists is deprecated, use proper exception handling")
|
|
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. DEPRECATED: Use proper exception handling."""
|
|
logger.warning("shop_exists is deprecated, use proper exception handling")
|
|
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()
|