use crate::shared::errors::Error;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ComplianceErrorKey {
#[serde(rename = "COMPLIANCE_UNAUTHORIZED")]
ComplianceUnauthorized,
#[serde(rename = "COMPLIANCE_INSUFFICIENT_SCOPE")]
ComplianceInsufficientScope,
#[serde(rename = "COMPLIANCE_STEP_UP_REQUIRED")]
ComplianceStepUpRequired,
#[serde(rename = "COMPLIANCE_TOKEN_INVALID")]
ComplianceTokenInvalid,
#[serde(rename = "SUBJECT_SNAPSHOT_REQUIRED")]
SubjectSnapshotRequired,
#[serde(rename = "SUBJECT_SNAPSHOT_NOT_FOUND")]
SubjectSnapshotNotFound,
#[serde(rename = "SUBJECT_SNAPSHOT_TENANT_MISMATCH")]
SubjectSnapshotTenantMismatch,
#[serde(rename = "EVIDENCE_ASSET_NOT_FOUND")]
EvidenceAssetNotFound,
#[serde(rename = "EVIDENCE_ASSET_HASH_MISMATCH")]
EvidenceAssetHashMismatch,
#[serde(rename = "EVIDENCE_ASSET_PAYLOAD_REQUIRED")]
EvidenceAssetPayloadRequired,
#[serde(rename = "TIMESTAMP_TOKEN_NOT_FOUND")]
TimestampTokenNotFound,
#[serde(rename = "TIMESTAMP_PROVIDER_FAILED")]
TimestampProviderFailed,
#[serde(rename = "TIMESTAMP_PROVIDER_UNKNOWN")]
TimestampProviderUnknown,
#[serde(rename = "TIMESTAMP_LOCAL_VERIFY_FAILED")]
TimestampLocalVerifyFailed,
#[serde(rename = "TIMESTAMP_PROVIDER_NOT_AVAILABLE")]
TimestampProviderNotAvailable,
#[serde(rename = "EVIDENCE_PACKAGE_NOT_FOUND")]
EvidencePackageNotFound,
#[serde(rename = "EVIDENCE_PACKAGE_TIMESTAMP_REQUIRED")]
EvidencePackageTimestampRequired,
#[serde(rename = "EVIDENCE_PACKAGE_MANIFEST_HASH_MISMATCH")]
EvidencePackageManifestHashMismatch,
#[serde(rename = "REPORT_NOT_FOUND")]
ReportNotFound,
#[serde(rename = "REPORT_ALREADY_PUBLISHED")]
ReportAlreadyPublished,
#[serde(rename = "REPORT_DRAFT_REQUIRED")]
ReportDraftRequired,
#[serde(rename = "EVIDENCE_VERIFY_TARGET_REQUIRED")]
EvidenceVerifyTargetRequired,
#[serde(rename = "EVIDENCE_VERIFY_TARGET_NOT_FOUND")]
EvidenceVerifyTargetNotFound,
#[serde(rename = "PROVIDER_REQUEST_UNKNOWN_NO_RETRY")]
ProviderRequestUnknownNoRetry,
#[serde(rename = "PROVIDER_CALLBACK_SOURCE_INVALID")]
ProviderCallbackSourceInvalid,
#[serde(rename = "PROVIDER_NOT_CONFIGURED")]
ProviderNotConfigured,
#[serde(rename = "PROVIDER_REQUEST_NOT_FOUND")]
ProviderRequestNotFound,
#[serde(rename = "PROVIDER_REQUEST_IDEMPOTENCY_REQUIRED")]
ProviderRequestIdempotencyRequired,
#[serde(rename = "PROVIDER_REQUEST_STATUS_NOT_TERMINAL")]
ProviderRequestStatusNotTerminal,
#[serde(rename = "ENVELOPE_NOT_FOUND")]
EnvelopeNotFound,
#[serde(rename = "ENVELOPE_TENANT_MISMATCH")]
EnvelopeTenantMismatch,
#[serde(rename = "ENVELOPE_STATE_NOT_ALLOWED")]
EnvelopeStateNotAllowed,
#[serde(rename = "ENVELOPE_GATE_CLOSED")]
EnvelopeGateClosed,
#[serde(rename = "CONTRACT_NOT_FOUND")]
ContractNotFound,
#[serde(rename = "CONTRACT_HASH_MISMATCH")]
ContractHashMismatch,
#[serde(rename = "PROVIDER_AUTHORIZATION_NOT_CONFIRMED")]
ProviderAuthorizationNotConfirmed,
#[serde(rename = "ENVELOPE_EVIDENCE_NOT_READY")]
EnvelopeEvidenceNotReady,
#[serde(rename = "SEAL_ASSET_NOT_FOUND")]
SealAssetNotFound,
#[serde(rename = "SEAL_APPROVAL_NOT_FOUND")]
SealApprovalNotFound,
#[serde(rename = "SEAL_APPROVAL_STATE_NOT_APPROVED")]
SealApprovalStateNotApproved,
#[serde(rename = "SEAL_APPROVAL_EXPIRED")]
SealApprovalExpired,
#[serde(rename = "SEAL_APPROVAL_ALREADY_USED")]
SealApprovalAlreadyUsed,
#[serde(rename = "SEAL_APPROVAL_NONCE_USED")]
SealApprovalNonceUsed,
#[serde(rename = "SEAL_APPROVAL_SEAL_MISMATCH")]
SealApprovalSealMismatch,
#[serde(rename = "SEAL_APPROVAL_LOCATION_MISMATCH")]
SealApprovalLocationMismatch,
#[serde(rename = "SEAL_APPROVAL_TRANSACTOR_MISMATCH")]
SealApprovalTransactorMismatch,
#[serde(rename = "SEAL_APPROVAL_CONTRACT_HASH_MISMATCH")]
SealApprovalContractHashMismatch,
#[serde(rename = "SEAL_APPROVAL_INVALID_TRANSITION")]
SealApprovalInvalidTransition,
#[serde(rename = "SEAL_USE_ALREADY_CONSUMED")]
SealUseAlreadyConsumed,
#[serde(rename = "AUDIT_CHAIN_TAMPER_DETECTED")]
AuditChainTamperDetected,
#[serde(rename = "BILLING_COMMIT_REQUIRES_LOCAL_VERIFY")]
BillingCommitRequiresLocalVerify,
#[serde(rename = "BILLING_COMMIT_REQUIRES_PROVIDER_SUCCESS")]
BillingCommitRequiresProviderSuccess,
#[serde(rename = "BILLING_CALLBACK_CANNOT_COMMIT")]
BillingCallbackCannotCommit,
#[serde(rename = "BILLING_PROVIDER_UNKNOWN_NOT_COMMITTABLE")]
BillingProviderUnknownNotCommittable,
#[serde(rename = "BILLING_S2S_FORBIDDEN")]
BillingS2sForbidden,
#[serde(rename = "UNKNOWN_COMPLIANCE_ERROR")]
UnknownComplianceError,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ComplianceErrorInfo {
pub code: i64,
pub message: String,
pub key: ComplianceErrorKey,
pub retryable: bool,
pub terminal: bool,
#[serde(rename = "stepUpRequired")]
pub step_up_required: bool,
}
fn code_to_key(code: i64) -> Option<ComplianceErrorKey> {
use ComplianceErrorKey as K;
Some(match code {
1031000001 => K::ComplianceUnauthorized,
1031000002..=1031000011 => K::ComplianceTokenInvalid,
1031000012 => K::ComplianceInsufficientScope,
1031000013 => K::ComplianceStepUpRequired,
1031001001 => K::SubjectSnapshotNotFound,
1031001002 => K::SubjectSnapshotTenantMismatch,
1031001003 => K::SubjectSnapshotRequired,
1031002001 => K::EvidenceAssetNotFound,
1031002002 => K::SubjectSnapshotTenantMismatch,
1031002003 => K::EvidenceAssetHashMismatch,
1031002004 | 1031002005 => K::EvidenceAssetPayloadRequired,
1031002006 => K::TimestampTokenNotFound,
1031002007 => K::TimestampProviderFailed,
1031002008 => K::TimestampProviderUnknown,
1031002009 => K::TimestampLocalVerifyFailed,
1031002010 => K::TimestampProviderNotAvailable,
1031002011 => K::EvidencePackageNotFound,
1031002012 => K::EvidencePackageTimestampRequired,
1031002013 => K::EvidencePackageManifestHashMismatch,
1031002014 => K::ReportNotFound,
1031002015 => K::ReportAlreadyPublished,
1031002016 => K::ReportDraftRequired,
1031002017 => K::EvidenceVerifyTargetRequired,
1031002018 => K::EvidenceVerifyTargetNotFound,
1031003001 => K::ProviderRequestUnknownNoRetry,
1031003002 => K::ProviderCallbackSourceInvalid,
1031003003 => K::ProviderNotConfigured,
1031003010 => K::ProviderRequestNotFound,
1031003011 => K::ProviderRequestIdempotencyRequired,
1031003012 => K::ProviderRequestStatusNotTerminal,
1031004001 => K::EnvelopeNotFound,
1031004002 => K::EnvelopeTenantMismatch,
1031004003 => K::EnvelopeStateNotAllowed,
1031004004 => K::EnvelopeGateClosed,
1031004005 => K::ContractNotFound,
1031004006 => K::ContractHashMismatch,
1031004007 => K::ContractNotFound,
1031004008 | 1031004009 => K::ProviderAuthorizationNotConfirmed,
1031004010 => K::EnvelopeEvidenceNotReady,
1031005001 => K::SealAssetNotFound,
1031005010 | 1031005011 => K::SealApprovalNotFound,
1031005012 => K::SealApprovalStateNotApproved,
1031005013 => K::SealApprovalExpired,
1031005014 => K::SealApprovalAlreadyUsed,
1031005015 => K::SealApprovalNonceUsed,
1031005016 => K::SealApprovalSealMismatch,
1031005017 => K::SealApprovalLocationMismatch,
1031005018 => K::SealApprovalTransactorMismatch,
1031005019 => K::SealApprovalContractHashMismatch,
1031005020 => K::SealApprovalInvalidTransition,
1031005030 => K::SealUseAlreadyConsumed,
1031006004 => K::BillingCommitRequiresLocalVerify,
1031006005 => K::BillingCommitRequiresProviderSuccess,
1031006007 => K::BillingCallbackCannotCommit,
1031006008 => K::BillingProviderUnknownNotCommittable,
1031006009 => K::BillingS2sForbidden,
1031007011 => K::AuditChainTamperDetected,
_ => return None,
})
}
fn is_step_up_key(key: ComplianceErrorKey) -> bool {
matches!(key, ComplianceErrorKey::ComplianceStepUpRequired)
}
fn is_terminal_key(key: ComplianceErrorKey) -> bool {
use ComplianceErrorKey as K;
matches!(
key,
K::EnvelopeGateClosed
| K::ProviderNotConfigured
| K::ProviderRequestUnknownNoRetry
| K::BillingCallbackCannotCommit
| K::BillingCommitRequiresLocalVerify
| K::BillingCommitRequiresProviderSuccess
| K::BillingProviderUnknownNotCommittable
| K::BillingS2sForbidden
| K::SealApprovalNonceUsed
| K::SealApprovalExpired
| K::SealApprovalContractHashMismatch
| K::SealApprovalSealMismatch
| K::SealApprovalLocationMismatch
| K::SealApprovalTransactorMismatch
| K::SealUseAlreadyConsumed
| K::ContractHashMismatch
| K::TimestampLocalVerifyFailed
| K::EvidencePackageManifestHashMismatch
| K::AuditChainTamperDetected
| K::ProviderRequestNotFound
| K::EvidenceAssetHashMismatch
| K::EvidenceVerifyTargetNotFound
| K::ReportAlreadyPublished
)
}
fn is_retryable_key(_key: ComplianceErrorKey) -> bool {
false
}
pub fn classify_compliance_error(err: &Error) -> ComplianceErrorInfo {
let (code, message) = match err {
Error::Business { code, message } => (*code, message.clone()),
_ => (0, err.to_string()),
};
let key = code_to_key(code).unwrap_or(ComplianceErrorKey::UnknownComplianceError);
ComplianceErrorInfo {
code,
message,
key,
retryable: is_retryable_key(key),
terminal: is_terminal_key(key),
step_up_required: is_step_up_key(key),
}
}
pub fn is_compliance_business_error(err: &Error) -> bool {
matches!(err, Error::Business { code, .. } if (1031000000..=1031999999).contains(code))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn key_serializes_to_symbolic_string() {
let s = serde_json::to_string(&ComplianceErrorKey::EnvelopeGateClosed).unwrap();
assert_eq!(s, "\"ENVELOPE_GATE_CLOSED\"");
let back: ComplianceErrorKey =
serde_json::from_str("\"SEAL_USE_ALREADY_CONSUMED\"").unwrap();
assert_eq!(back, ComplianceErrorKey::SealUseAlreadyConsumed);
}
#[test]
fn classify_step_up() {
let info = classify_compliance_error(&Error::business(1031000013, "需 step-up"));
assert_eq!(info.key, ComplianceErrorKey::ComplianceStepUpRequired);
assert!(info.step_up_required);
assert!(!info.terminal);
assert!(!info.retryable);
}
#[test]
fn classify_terminal_gate_closed() {
let info = classify_compliance_error(&Error::business(1031004004, "gate closed"));
assert_eq!(info.key, ComplianceErrorKey::EnvelopeGateClosed);
assert!(info.terminal);
assert!(!info.step_up_required);
}
#[test]
fn classify_token_invalid_band() {
for code in [1031000002, 1031000007, 1031000011] {
let info = classify_compliance_error(&Error::business(code, "x"));
assert_eq!(info.key, ComplianceErrorKey::ComplianceTokenInvalid);
}
}
#[test]
fn classify_unknown_out_of_band() {
let info = classify_compliance_error(&Error::business(9999, "other module"));
assert_eq!(info.key, ComplianceErrorKey::UnknownComplianceError);
assert!(!info.terminal);
}
#[test]
fn is_compliance_band_detection() {
assert!(is_compliance_business_error(&Error::business(
1031004004, ""
)));
assert!(!is_compliance_business_error(&Error::business(
1010000001, ""
)));
assert!(!is_compliance_business_error(&Error::other("not business")));
}
}