kami_spider_monorepo/apps/app_a/services.py

"""
App A Services - Business logic layer.
"""

from typing import Optional
from datetime import datetime
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from apps.app_a.models import User
from apps.app_a.schemas import UserCreate, UserUpdate
from core.exceptions import NotFoundException, AlreadyExistsException


class UserService:
    """Service for user business logic."""
    
    @staticmethod
    async def create_user(
        session: AsyncSession,
        user_data: UserCreate
    ) -> User:
        """
        Create a new user.
        
        Args:
            session: Database session
            user_data: User creation data
        
        Returns:
            User: Created user
        
        Raises:
            AlreadyExistsException: If username or email already exists
        """
        # Check if username exists
        result = await session.execute(
            select(User).where(User.username == user_data.username)
        )
        if result.scalar_one_or_none():
            raise AlreadyExistsException(
                message=f"Username '{user_data.username}' already exists",
                resource="User"
            )
        
        # Check if email exists
        result = await session.execute(
            select(User).where(User.email == user_data.email)
        )
        if result.scalar_one_or_none():
            raise AlreadyExistsException(
                message=f"Email '{user_data.email}' already exists",
                resource="User"
            )
        
        # Create user (in production, hash the password)
        user = User(
            username=user_data.username,
            email=user_data.email,
            full_name=user_data.full_name,
            hashed_password=f"hashed_{user_data.password}",  # TODO: Use proper hashing
            created_at=datetime.utcnow(),
            updated_at=datetime.utcnow()
        )
        
        session.add(user)
        await session.commit()
        await session.refresh(user)
        
        return user
    
    @staticmethod
    async def get_user(
        session: AsyncSession,
        user_id: int
    ) -> User:
        """
        Get user by ID.
        
        Args:
            session: Database session
            user_id: User ID
        
        Returns:
            User: User instance
        
        Raises:
            NotFoundException: If user not found
        """
        result = await session.execute(
            select(User).where(User.id == user_id)
        )
        user = result.scalar_one_or_none()
        
        if not user:
            raise NotFoundException(
                message=f"User with ID {user_id} not found",
                resource="User"
            )
        
        return user
    
    @staticmethod
    async def list_users(
        session: AsyncSession,
        skip: int = 0,
        limit: int = 100
    ) -> tuple[list[User], int]:
        """
        List all users with pagination.
        
        Args:
            session: Database session
            skip: Number of records to skip
            limit: Maximum number of records to return
        
        Returns:
            tuple: (list of users, total count)
        """
        # Get total count
        count_result = await session.execute(
            select(User)
        )
        total = len(count_result.all())
        
        # Get paginated results
        result = await session.execute(
            select(User).offset(skip).limit(limit)
        )
        users = result.scalars().all()
        
        return list(users), total
    
    @staticmethod
    async def update_user(
        session: AsyncSession,
        user_id: int,
        user_data: UserUpdate
    ) -> User:
        """
        Update user.
        
        Args:
            session: Database session
            user_id: User ID
            user_data: Update data
        
        Returns:
            User: Updated user
        
        Raises:
            NotFoundException: If user not found
        """
        user = await UserService.get_user(session, user_id)
        
        # Update fields
        if user_data.email is not None:
            user.email = user_data.email
        if user_data.full_name is not None:
            user.full_name = user_data.full_name
        if user_data.is_active is not None:
            user.is_active = user_data.is_active
        
        user.updated_at = datetime.utcnow()
        
        await session.commit()
        await session.refresh(user)
        
        return user
    
    @staticmethod
    async def delete_user(
        session: AsyncSession,
        user_id: int
    ) -> None:
        """
        Delete user.
        
        Args:
            session: Database session
            user_id: User ID
        
        Raises:
            NotFoundException: If user not found
        """
        user = await UserService.get_user(session, user_id)
        await session.delete(user)
        await session.commit()