NAC_Blockchain/_archive/nac-onboarding-system-legacy/src/error.rs

// NAC资产一键上链系统 - 错误处理模块
// 定义所有可能的错误类型

use actix_web::{error::ResponseError, http::StatusCode, HttpResponse};
use serde::{Deserialize, Serialize};
use std::fmt;
use thiserror::Error;

/// 系统错误类型
#[derive(Error, Debug)]
pub enum OnboardingError {
    /// 数据库错误
    #[error("数据库错误: {0}")]
    DatabaseError(String),

    /// SDK适配器错误
    #[error("SDK适配器错误: {0}")]
    AdapterError(String),

    /// AI合规审批错误
    #[error("AI合规审批错误: {0}")]
    ComplianceError(String),

    /// AI估值错误
    #[error("AI估值错误: {0}")]
    ValuationError(String),

    /// DNA生成错误
    #[error("DNA生成错误: {0}")]
    DNAError(String),

    /// 宪法执行引擎错误
    #[error("宪法执行引擎错误: {0}")]
    ConstitutionError(String),

    /// 托管对接错误
    #[error("托管对接错误: {0}")]
    CustodyError(String),

    /// XTZH铸造错误
    #[error("XTZH铸造错误: {0}")]
    XTZHError(String),

    /// 代币发行错误
    #[error("代币发行错误: {0}")]
    TokenError(String),

    /// 链上公示错误
    #[error("链上公示错误: {0}")]
    ListingError(String),

    /// 认证错误
    #[error("认证错误: {0}")]
    AuthError(String),

    /// 参数验证错误
    #[error("参数验证错误: {0}")]
    ValidationError(String),

    /// 资源未找到
    #[error("资源未找到: {0}")]
    NotFound(String),

    /// 权限不足
    #[error("权限不足: {0}")]
    PermissionDenied(String),

    /// 内部错误
    #[error("内部错误: {0}")]
    InternalError(String),

    /// NAC Lens4协议错误
    #[error("NAC Lens4协议错误: {0}")]
    NAC Lens4Error(String),
}

/// 错误响应结构
#[derive(Debug, Serialize, Deserialize)]
pub struct ErrorResponse {
    pub success: bool,
    pub error: ErrorDetail,
}

/// 错误详情
#[derive(Debug, Serialize, Deserialize)]
pub struct ErrorDetail {
    pub code: String,
    pub message: String,
    pub details: Option<String>,
}

impl ResponseError for OnboardingError {
    fn error_response(&self) -> HttpResponse {
        let (status_code, error_code) = match self {
            OnboardingError::DatabaseError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "DB_ERROR"),
            OnboardingError::AdapterError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "ADAPTER_ERROR"),
            OnboardingError::ComplianceError(_) => (StatusCode::BAD_REQUEST, "COMPLIANCE_ERROR"),
            OnboardingError::ValuationError(_) => (StatusCode::BAD_REQUEST, "VALUATION_ERROR"),
            OnboardingError::DNAError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "DNA_ERROR"),
            OnboardingError::ConstitutionError(_) => (StatusCode::BAD_REQUEST, "CONSTITUTION_ERROR"),
            OnboardingError::CustodyError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "CUSTODY_ERROR"),
            OnboardingError::XTZHError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "XTZH_ERROR"),
            OnboardingError::TokenError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "TOKEN_ERROR"),
            OnboardingError::ListingError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "LISTING_ERROR"),
            OnboardingError::AuthError(_) => (StatusCode::UNAUTHORIZED, "AUTH_ERROR"),
            OnboardingError::ValidationError(_) => (StatusCode::BAD_REQUEST, "VALIDATION_ERROR"),
            OnboardingError::NotFound(_) => (StatusCode::NOT_FOUND, "NOT_FOUND"),
            OnboardingError::PermissionDenied(_) => (StatusCode::FORBIDDEN, "PERMISSION_DENIED"),
            OnboardingError::InternalError(_) => (StatusCode::INTERNAL_SERVER_ERROR, "INTERNAL_ERROR"),
            OnboardingError::NAC Lens4Error(_) => (StatusCode::INTERNAL_SERVER_ERROR, "NAC Lens4_ERROR"),
        };

        let error_response = ErrorResponse {
            success: false,
            error: ErrorDetail {
                code: error_code.to_string(),
                message: self.to_string(),
                details: None,
            },
        };

        HttpResponse::build(status_code).json(error_response)
    }

    fn status_code(&self) -> StatusCode {
        match self {
            OnboardingError::DatabaseError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::AdapterError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::ComplianceError(_) => StatusCode::BAD_REQUEST,
            OnboardingError::ValuationError(_) => StatusCode::BAD_REQUEST,
            OnboardingError::DNAError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::ConstitutionError(_) => StatusCode::BAD_REQUEST,
            OnboardingError::CustodyError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::XTZHError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::TokenError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::ListingError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::AuthError(_) => StatusCode::UNAUTHORIZED,
            OnboardingError::ValidationError(_) => StatusCode::BAD_REQUEST,
            OnboardingError::NotFound(_) => StatusCode::NOT_FOUND,
            OnboardingError::PermissionDenied(_) => StatusCode::FORBIDDEN,
            OnboardingError::InternalError(_) => StatusCode::INTERNAL_SERVER_ERROR,
            OnboardingError::NAC Lens4Error(_) => StatusCode::INTERNAL_SERVER_ERROR,
        }
    }
}

/// 将sqlx错误转换为OnboardingError
impl From<sqlx::Error> for OnboardingError {
    fn from(err: sqlx::Error) -> Self {
        OnboardingError::DatabaseError(err.to_string())
    }
}

/// 将serde_json错误转换为OnboardingError
impl From<serde_json::Error> for OnboardingError {
    fn from(err: serde_json::Error) -> Self {
        OnboardingError::InternalError(format!("JSON序列化错误: {}", err))
    }
}

/// Result类型别名
pub type Result<T> = std::result::Result<T, OnboardingError>;