saas_backend/app/routes/admin/module_environments.py

import uuid as uuid_module
from typing import List
from fastapi import APIRouter, Depends, Request
from sqlalchemy.orm import Session

from app.config.database import get_db
from app.middleware.auth_middleware import get_current_user, require_access, User
from app.controllers.auth.module_environment_controller import ModuleEnvironmentController
from app.models.auth.module_environment_model import ModuleEnvironment
from app.schemas.auth.module_environment_schema import EnvironmentCreate, EnvironmentResponse, EnvironmentUpdate
from app.services.auth.module_service import ModuleService
from app.services.system.audit_log_service import AuditLogService
from app.helper.helpers import get_client_ip

router = APIRouter()

def _get_env_snapshot(db: Session, module_id: str, env_id: str) -> dict:
    """Helper to capture state before changes for the Audit Log."""
    try:
        env = db.query(ModuleEnvironment).filter(
            ModuleEnvironment.id == uuid_module.UUID(env_id),
            ModuleEnvironment.module_id == uuid_module.UUID(module_id)
        ).first()
        if not env: return {}
        return {
            "slug": env.slug,
            "backend_base_url": env.backend_base_url,
            "is_default": env.is_default,
            "is_active": env.is_active
        }
    except: return {}

@router.get("/{module_id}/environments", response_model=List[EnvironmentResponse])
def list_environments(
    module_id: str,
    current_user: User = Depends(get_current_user),
    _: bool = Depends(require_access("modules.view")),
    db: Session = Depends(get_db)
):
    return ModuleEnvironmentController.list_environments(db, module_id)

@router.post("/{module_id}/environments", response_model=EnvironmentResponse, status_code=201)
def create_environment(
    request: Request,
    module_id: str,
    env_data: EnvironmentCreate,
    current_user: User = Depends(get_current_user),
    _: bool = Depends(require_access("modules.manage")),
    db: Session = Depends(get_db)
):
    module = ModuleService.get_module(db, module_id)
    result = ModuleEnvironmentController.create_environment(db, module_id, env_data)

    AuditLogService.log(
        db=db,
        module_name="Module Environments",
        action_type="CREATE",
        entity_id=str(result.id),
        entity_name=f"{module.module_name} / {result.slug}",
        description=f"Environment '{result.slug}' created for '{module.module_name}'",
        performed_by_id=str(current_user.id),
        performed_by_email=current_user.email,
        ip_address=get_client_ip(request),
        new_values=env_data.model_dump(exclude={"trust_credentials"})
    )
    return result

@router.put("/{module_id}/environments/{env_id}", response_model=EnvironmentResponse)
def update_environment(
    request: Request,
    module_id: str,
    env_id: str,
    env_data: EnvironmentUpdate,
    current_user: User = Depends(get_current_user),
    _: bool = Depends(require_access("modules.manage")),
    db: Session = Depends(get_db)
):
    module = ModuleService.get_module(db, module_id)
    old_values = _get_env_snapshot(db, module_id, env_id)

    result = ModuleEnvironmentController.update_environment(db, module_id, env_id, env_data)

    AuditLogService.log(
        db=db,
        module_name="Module Environments",
        action_type="UPDATE",
        entity_id=env_id,
        entity_name=f"{module.module_name} / {result.slug}",
        description=f"Environment '{result.slug}' updated",
        performed_by_id=str(current_user.id),
        performed_by_email=current_user.email,
        ip_address=get_client_ip(request),
        old_values=old_values,
        new_values=env_data.model_dump(exclude_unset=True, exclude={"trust_credentials"})
    )
    return result

@router.patch("/{module_id}/environments/{env_id}/default")
def set_default_environment(
    request: Request,
    module_id: str,
    env_id: str,
    current_user: User = Depends(get_current_user),
    _: bool = Depends(require_access("modules.manage")),
    db: Session = Depends(get_db)
):
    module = ModuleService.get_module(db, module_id)
    result = ModuleEnvironmentController.set_default_environment(db, module_id, env_id)

    AuditLogService.log(
        db=db,
        module_name="Module Environments",
        action_type="UPDATE",
        entity_id=env_id,
        entity_name=f"{module.module_name}",
        description=f"Set default environment for {module.module_name}",
        performed_by_id=str(current_user.id),
        performed_by_email=current_user.email,
        ip_address=get_client_ip(request),
        new_values={"is_default": True}
    )
    return result

@router.delete("/{module_id}/environments/{env_id}")
def delete_environment(
    request: Request,
    module_id: str,
    env_id: str,
    current_user: User = Depends(get_current_user),
    _: bool = Depends(require_access("modules.manage")),
    db: Session = Depends(get_db)
):
    module = ModuleService.get_module(db, module_id)
    snapshot = _get_env_snapshot(db, module_id, env_id)

    result = ModuleEnvironmentController.delete_environment(db, module_id, env_id)

    AuditLogService.log(
        db=db,
        module_name="Module Environments",
        action_type="DELETE",
        entity_id=env_id,
        entity_name=f"{module.module_name} / {snapshot.get('slug')}",
        description=f"Environment deleted from {module.module_name}",
        performed_by_id=str(current_user.id),
        performed_by_email=current_user.email,
        ip_address=get_client_ip(request),
        old_values=snapshot
    )
    return result