alou 0.1.6

智能自动化工作流系统 - 基于Rust和Model Context Protocol (MCP)的智能体
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// ============================================
// Invitation Codes API Endpoints
// ============================================

use sqlx::PgPool;
use warp::{reply, Rejection, Reply};
use chrono::Utc;
use warp::http::StatusCode;
use serde::Deserialize;

// 在handler函数上方添加新的导入
use crate::models::invitation_codes::UseInvitationCodeRequest;
use crate::models::invitation_codes::UseInvitationCodeResponse;
use crate::models::invitation_codes::CheckUserInvitationResponse;

use crate::models::invitation_codes::{InvitationCode, GenerateInvitationCodesRequest, GenerateInvitationCodesResponse};

// ============================================
// Handler Functions
// ============================================

#[derive(Debug, Deserialize)]
pub struct CheckUserInvitationRequest {
    pub user_id: i64,
}
/// 处理生成邀请码的请求
pub async fn handle_generate_invitation_codes(
    req: GenerateInvitationCodesRequest,
    pool: PgPool,
) -> Result<impl Reply, Rejection> {
    // 限制一次最多生成100个邀请码
    if req.num > 100 {
        return Ok(reply::with_status(
            reply::json(&GenerateInvitationCodesResponse {
                status: "error".to_string(),
                message: "Cannot generate more than 100 codes at once".to_string(),
                codes: vec![],
                timestamp: Utc::now().timestamp_millis() as u64,
            }),
            warp::http::StatusCode::BAD_REQUEST,
        ));
    }

    match InvitationCode::generate_codes(&pool, req.num).await {
        Ok(codes) => {
            Ok(reply::with_status(
                reply::json(&GenerateInvitationCodesResponse {
                    status: "success".to_string(),
                    message: format!("Successfully generated {} invitation codes", codes.len()),
                    codes,
                    timestamp: Utc::now().timestamp_millis() as u64
                }),
                warp::http::StatusCode::OK,
            ))
        }
        Err(e) => {
            eprintln!("Failed to generate invitation codes: {}", e);
            Ok(reply::with_status(
                reply::json(&GenerateInvitationCodesResponse {
                    status: "error".to_string(),
                    message: "Failed to generate invitation codes".to_string(),
                    codes: vec![],
                    timestamp: Utc::now().timestamp_millis() as u64,
                }),
                warp::http::StatusCode::INTERNAL_SERVER_ERROR,
            ))
        }
    }
}

/// 处理使用邀请码的请求
pub async fn handle_use_invitation_code(
    req: UseInvitationCodeRequest,
    pool: PgPool,
) -> Result<impl Reply, Rejection> {
    match InvitationCode::use_invitation_code(&pool, req.user_id, &req.code).await {
        Ok(()) => {
            Ok(reply::with_status(
                reply::json(&UseInvitationCodeResponse {
                    status: "success".to_string(),
                    message: "Invitation code used successfully".to_string(),
                    timestamp: Utc::now().timestamp_millis() as u64,
                }),
                StatusCode::OK,
            ))
        }
        Err(sqlx::Error::RowNotFound) => {
            Ok(reply::with_status(
                reply::json(&UseInvitationCodeResponse {
                    status: "error".to_string(),
                    message: "Invitation code not found or already used".to_string(),
                    timestamp: Utc::now().timestamp_millis() as u64,
                }),
                StatusCode::BAD_REQUEST,
            ))
        }
        Err(e) => {
            eprintln!("Failed to use invitation code: {}", e);
            Ok(reply::with_status(
                reply::json(&UseInvitationCodeResponse {
                    status: "error".to_string(),
                    message: "Failed to use invitation code".to_string(),
                    timestamp: Utc::now().timestamp_millis() as u64,
                }),
                StatusCode::INTERNAL_SERVER_ERROR,
            ))
        }
    }
}

/// 处理检查用户是否有激活邀请码的请求
pub async fn handle_check_user_invitation(
    req: CheckUserInvitationRequest,
    pool: PgPool,
) -> Result<impl Reply, Rejection> {
    match InvitationCode::check_user_has_active_invitation(&pool, req.user_id).await {
        Ok(has_active) => {
            Ok(reply::with_status(
                reply::json(&CheckUserInvitationResponse {
                    status: "success".to_string(),
                    has_active_invitation: has_active,
                    message: if has_active {
                        "User has active invitation code".to_string()
                    } else {
                        "User has no active invitation code".to_string()
                    },
                    timestamp: Utc::now().timestamp_millis() as u64,
                }),
                StatusCode::OK,
            ))
        }
        Err(e) => {
            eprintln!("Failed to check user invitation: {}", e);
            Ok(reply::with_status(
                reply::json(&CheckUserInvitationResponse {
                    status: "error".to_string(),
                    has_active_invitation: false,
                    message: "Failed to check user invitation".to_string(),
                    timestamp: Utc::now().timestamp_millis() as u64,
                }),
                StatusCode::INTERNAL_SERVER_ERROR,
            ))
        }
    }
}