unis 0.1.2

轻量级CQRS框架。
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use axum::{http::StatusCode, response::IntoResponse};

/// 命令处理结果枚举
#[repr(u8)]
#[derive(Debug, PartialEq)]
pub enum UniResponse {
    /// 成功
    Success = 0,
    /// 命令数据验证错误
    ValidateError = 1,
    /// 身份验证错误
    AuthError = 2,
    /// 请求超时
    Timeout = 3,
    /// 被冲突的新命令取代
    Conflict = 4,
    /// 命令已执行成功
    Duplicate = 11,
    /// 命令无法应用到聚合
    CheckError = 12,
    /// 序列化错误
    CodeError = 13,
    /// 消息处理错误
    MsgError = 14,
    /// 写入事件流错误
    WriteError = 15,
    /// 读取事件流错误
    ReadError = 16,
    /// 写入命令流错误
    SendError = 17,
}

impl UniResponse {
    /// 反序列化
    pub fn from_bytes(res_data: &[u8]) -> Self {
        match res_data[0] {
            0 => UniResponse::Success,
            1 => UniResponse::ValidateError,
            2 => UniResponse::AuthError,
            3 => UniResponse::Timeout,
            4 => UniResponse::Conflict,
            11 => UniResponse::Duplicate,
            12 => UniResponse::CheckError,
            13 => UniResponse::CodeError,
            14 => UniResponse::MsgError,
            15 => UniResponse::WriteError,
            16 => UniResponse::ReadError,
            17 => UniResponse::SendError,
            _ => panic!("转换命令处理结果枚举失败"),
        }
    }
    /// 序列化
    pub fn to_bytes(self) -> [u8; 1] {
        [self as u8]
    }
}

impl std::fmt::Display for UniResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            UniResponse::Success => write!(f, "成功"),
            UniResponse::ValidateError => write!(f, "命令数据验证错误"),
            UniResponse::AuthError => write!(f, "身份验证错误"),
            UniResponse::Timeout => write!(f, "请求超时"),
            UniResponse::Conflict => write!(f, "被冲突的新命令取代"),
            UniResponse::Duplicate => write!(f, "命令已执行成功"),
            UniResponse::CheckError => write!(f, "命令无法应用到聚合"),
            UniResponse::CodeError => write!(f, "序列化错误"),
            UniResponse::MsgError => write!(f, "消息处理错误"),
            UniResponse::WriteError => write!(f, "写入事件流错误"),
            UniResponse::ReadError => write!(f, "读取事件流错误"),
            UniResponse::SendError => write!(f, "写入命令流错误"),
        }
    }
}

impl IntoResponse for UniResponse {
    fn into_response(self) -> axum::response::Response {
        match self {
            UniResponse::Success => (StatusCode::OK, "成功").into_response(),
            UniResponse::ValidateError => {
                (StatusCode::BAD_REQUEST, "命令数据验证错误").into_response()
            }
            UniResponse::AuthError => (StatusCode::UNAUTHORIZED, "身份验证错误").into_response(),
            UniResponse::Timeout => (StatusCode::REQUEST_TIMEOUT, "请求超时").into_response(),
            UniResponse::Conflict => (StatusCode::CONFLICT, "被冲突的新命令取代").into_response(),
            UniResponse::Duplicate => (StatusCode::OK, "命令已执行成功").into_response(),
            UniResponse::CheckError => {
                (StatusCode::BAD_REQUEST, "命令无法应用到聚合").into_response()
            }
            UniResponse::CodeError => {
                (StatusCode::INTERNAL_SERVER_ERROR, "序列化错误").into_response()
            }
            UniResponse::MsgError => {
                (StatusCode::INTERNAL_SERVER_ERROR, "消息处理错误").into_response()
            }
            UniResponse::WriteError => {
                (StatusCode::INTERNAL_SERVER_ERROR, "写入事件流错误").into_response()
            }
            UniResponse::ReadError => {
                (StatusCode::INTERNAL_SERVER_ERROR, "读取事件流错误").into_response()
            }
            UniResponse::SendError => {
                (StatusCode::INTERNAL_SERVER_ERROR, "写入命令流错误").into_response()
            }
        }
    }
}