343 lines
12 KiB
Python
343 lines
12 KiB
Python
# 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()
|