无服务器AI摘要后端——OrdChaosGPT

use actix_web::{post, web, App, HttpServer, Responder, HttpResponse, HttpRequest};
use serde::{Deserialize, Serialize};
use std::path::Path;
use std::fs;
use reqwest::Client;
use serde_json::json;

#[derive(Serialize, Deserialize)]
struct SummaryRequest {
    content: String,
    url: String,
}

#[derive(Serialize, Deserialize)]
struct SummaryResponse {
    url: String,
    summary: String,
}

struct AppState {
    auth_token: String,
}

const SUMMARY_DIR: &str = "summaries";

fn is_valid_referer(referer: Option<&str>) -> bool {
    if let Some(ref_url) = referer {
        let valid_domains = vec![
            ".ordchaos.com",
            ".ordchaos.top",
            ".ordchaos.eu.org",
        ];
        return valid_domains.iter().any(|domain| ref_url.ends_with(domain));
    }
    false
}

async fn generate_summary(content: &str) -> Result<String, Box<dyn std::error::Error>> {
    let api_key = "*******************************";
    let api_url = "https://dashscope.aliyuncs.com/compatible-mode/v1";
    let client = Client::new();

    let request_body = json!({
        "model": "qwen-long",
        "messages": [
            {"role": "system", "content": "You are a helpful summary generator."},
            {"role": "user", "content": format!("请为以下内容用中文生成长度为150汉字左右的摘要，摘要只有一个自然段，且只给出摘要即可，不要说其他任何话: {}", content)}
        ],
        "temperature": 0.8,
        "top_p": 0.8
    });

    let response = client
        .post(format!("{}/chat/completions", api_url))
        .header("Authorization", format!("Bearer {}", api_key))
        .json(&request_body)
        .send()
        .await?;

    let response_json: serde_json::Value = response.json().await?;
    let summary = response_json["choices"][0]["message"]["content"]
        .as_str()
        .unwrap_or("摘要生成失败：返回格式不正确")
        .to_string();

    Ok(summary.trim().to_string())
}

fn save_summary(abbrlink: &str, summary_data: &SummaryResponse) -> std::io::Result<()> {
    let summary_path = format!("{}/{}.json", SUMMARY_DIR, abbrlink);
    let json_data = serde_json::to_string(summary_data)?;
    fs::write(&summary_path, &json_data)?;
    Ok(())
}

fn load_summary(abbrlink: &str) -> Option<SummaryResponse> {
    let summary_path = format!("{}/{}.json", SUMMARY_DIR, abbrlink);
    if Path::new(&summary_path).exists() {
        if let Ok(json_data) = fs::read_to_string(&summary_path) {
            if let Ok(summary) = serde_json::from_str(&json_data) {
                return Some(summary);
            }
        }
    }
    None
}

#[post("/generate-summary")]
async fn generate_summary_handler(
    data: web::Data<AppState>,
    req: HttpRequest,
    summary_request: web::Json<SummaryRequest>
) -> impl Responder {
    if let Some(auth_header) = req.headers().get("Authorization") {
        let token = auth_header.to_str().unwrap_or("").trim_start_matches("Bearer ");
        if token != data.auth_token {
            return HttpResponse::Unauthorized().body("鉴权失败：Token不正确");
        }
    } else {
        return HttpResponse::Unauthorized().body("鉴权失败：缺失Token");
    }

    let referer = req.headers().get("Referer").and_then(|v| v.to_str().ok());
    let origin = req.headers().get("Origin").and_then(|v| v.to_str().ok());
    if !is_valid_referer(referer) && !is_valid_referer(origin) {
        return HttpResponse::Forbidden().body("拒绝生成摘要：来源不正确");
    }

    let abbrlink = summary_request.url
        .split('/')
        .filter(|&segment| !segment.is_empty())
        .last()
        .unwrap_or("");

    if abbrlink.is_empty() {
        return HttpResponse::BadRequest().body("Invalid URL format");
    }

    if let Some(existing_summary) = load_summary(abbrlink) {
        return HttpResponse::Ok().json(existing_summary);
    }

    let summary = match generate_summary(&summary_request.content).await {
        Ok(summary) => summary,
        Err(_) => return HttpResponse::InternalServerError().body("摘要生成失败"),
    };

    let summary_data = SummaryResponse {
        url: summary_request.url.clone(),
        summary: summary.clone(),
    };

    if let Err(err) = save_summary(abbrlink, &summary_data) {
        return HttpResponse::InternalServerError().body(format!("存储摘要失败： {}", err));
    }

    HttpResponse::Ok().json(summary_data)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    fs::create_dir_all(SUMMARY_DIR)?;
    let auth_token = std::env::var("AUTH_TOKEN").expect("AUTH_TOKEN 未被设置");

    println!("服务端已经在 http://localhost:11451 开启");

    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(AppState {
                auth_token: auth_token.clone(),
            }))
            .service(generate_summary_handler)
    })
    .bind("127.0.0.1:11451")?
    .run()
    .await
}