Add FastAPI application, API endpoints, Celery workers, and Docker configuration

Co-authored-by: christianlouis <361235+christianlouis@users.noreply.github.com>
2026-02-01 12:48:32 +00:00
parent 130b53d37f
commit 5be2794c95
18 changed files with 1648 additions and 0 deletions
@@ -0,0 +1,224 @@
+"""Mail account management endpoints"""
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, desc
+
+from app.core.database import get_db
+from app.core.deps import get_current_active_user
+from app.core.security import encrypt_credential, decrypt_credential
+from app.models.database_models import User, MailAccount
+from app.models.schemas import (
+    MailAccountCreate, MailAccountResponse, MailAccountUpdate,
+    MailAccountTestRequest, MailAccountTestResponse,
+    MailAccountAutoDetectRequest, MailAccountAutoDetectResponse
+)
+from app.services.mail_processor import MailProcessor, MailServerAutoDetect
+from app.core.config import settings
+
+router = APIRouter()
+
+
+@router.post("", response_model=MailAccountResponse, status_code=status.HTTP_201_CREATED)
+async def create_mail_account(
+    account_in: MailAccountCreate,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Create a new mail account"""
+    
+    # Check subscription limits
+    result = await db.execute(
+        select(MailAccount).where(MailAccount.user_id == current_user.id)
+    )
+    existing_accounts = result.scalars().all()
+    
+    tier_limits = {
+        "free": settings.TIER_FREE_MAX_ACCOUNTS,
+        "basic": settings.TIER_BASIC_MAX_ACCOUNTS,
+        "pro": settings.TIER_PRO_MAX_ACCOUNTS,
+        "enterprise": settings.TIER_ENTERPRISE_MAX_ACCOUNTS,
+    }
+    
+    max_accounts = tier_limits.get(current_user.subscription_tier.value, 1)
+    
+    if len(existing_accounts) >= max_accounts:
+        raise HTTPException(
+            status_code=status.HTTP_402_PAYMENT_REQUIRED,
+            detail=f"Account limit reached. Upgrade your subscription to add more accounts."
+        )
+    
+    # Encrypt password
+    encrypted_password = encrypt_credential(account_in.password)
+    
+    # Create account
+    account = MailAccount(
+        user_id=current_user.id,
+        name=account_in.name,
+        email_address=account_in.email_address,
+        protocol=account_in.protocol,
+        host=account_in.host,
+        port=account_in.port,
+        use_ssl=account_in.use_ssl,
+        use_tls=account_in.use_tls,
+        username=account_in.username,
+        encrypted_password=encrypted_password,
+        forward_to=account_in.forward_to,
+        is_enabled=account_in.is_enabled,
+        check_interval_minutes=account_in.check_interval_minutes,
+        max_emails_per_check=account_in.max_emails_per_check,
+        delete_after_forward=account_in.delete_after_forward
+    )
+    
+    db.add(account)
+    await db.commit()
+    await db.refresh(account)
+    
+    return account
+
+
+@router.get("", response_model=List[MailAccountResponse])
+async def list_mail_accounts(
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """List all mail accounts for current user"""
+    result = await db.execute(
+        select(MailAccount)
+        .where(MailAccount.user_id == current_user.id)
+        .order_by(desc(MailAccount.created_at))
+    )
+    accounts = result.scalars().all()
+    return accounts
+
+
+@router.get("/{account_id}", response_model=MailAccountResponse)
+async def get_mail_account(
+    account_id: int,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get a specific mail account"""
+    result = await db.execute(
+        select(MailAccount).where(
+            MailAccount.id == account_id,
+            MailAccount.user_id == current_user.id
+        )
+    )
+    account = result.scalar_one_or_none()
+    
+    if not account:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Mail account not found"
+        )
+    
+    return account
+
+
+@router.put("/{account_id}", response_model=MailAccountResponse)
+async def update_mail_account(
+    account_id: int,
+    account_update: MailAccountUpdate,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Update a mail account"""
+    result = await db.execute(
+        select(MailAccount).where(
+            MailAccount.id == account_id,
+            MailAccount.user_id == current_user.id
+        )
+    )
+    account = result.scalar_one_or_none()
+    
+    if not account:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Mail account not found"
+        )
+    
+    # Update fields
+    update_data = account_update.dict(exclude_unset=True)
+    
+    if "password" in update_data:
+        update_data["encrypted_password"] = encrypt_credential(update_data.pop("password"))
+    
+    for field, value in update_data.items():
+        setattr(account, field, value)
+    
+    await db.commit()
+    await db.refresh(account)
+    
+    return account
+
+
+@router.delete("/{account_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_mail_account(
+    account_id: int,
+    current_user: User = Depends(get_current_active_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Delete a mail account"""
+    result = await db.execute(
+        select(MailAccount).where(
+            MailAccount.id == account_id,
+            MailAccount.user_id == current_user.id
+        )
+    )
+    account = result.scalar_one_or_none()
+    
+    if not account:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Mail account not found"
+        )
+    
+    await db.delete(account)
+    await db.commit()
+
+
+@router.post("/test", response_model=MailAccountTestResponse)
+async def test_mail_connection(
+    test_request: MailAccountTestRequest,
+    current_user: User = Depends(get_current_active_user),
+):
+    """Test connection to mail server"""
+    
+    # Create temporary account for testing
+    temp_account = MailAccount(
+        user_id=current_user.id,
+        name="test",
+        email_address="test@test.com",
+        protocol=test_request.protocol,
+        host=test_request.host,
+        port=test_request.port,
+        use_ssl=test_request.use_ssl,
+        use_tls=test_request.use_tls,
+        username=test_request.username,
+        encrypted_password="",  # Not used for test
+        forward_to="test@test.com"
+    )
+    
+    processor = MailProcessor(temp_account, test_request.password)
+    success, message = await processor.test_connection()
+    
+    return MailAccountTestResponse(
+        success=success,
+        message=message
+    )
+
+
+@router.post("/auto-detect", response_model=MailAccountAutoDetectResponse)
+async def auto_detect_mail_settings(
+    detect_request: MailAccountAutoDetectRequest,
+    current_user: User = Depends(get_current_active_user),
+):
+    """Auto-detect mail server settings for an email address"""
+    
+    suggestions = MailServerAutoDetect.detect(detect_request.email_address)
+    
+    return MailAccountAutoDetectResponse(
+        success=len(suggestions) > 0,
+        suggestions=suggestions
+    )