zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
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

use crate::{map, prelude2::*};

use chrono::{DateTime, Offset, TimeZone, Utc};
use std::collections::HashMap;

pub async fn map_of(request: HttpRequest) -> impl Responder {
    let ctx = map!(
        "id",
        123,
        "name",
        "Alice",
        "active",
        true,
        "info",
        map!(
            "email",
            "alice@example.com",
            "age",
            28,
            "address",
            map!("city", "Shanghai", "zip", "200000")
        ),
        "tags",
        vec!["vip", "beta_user"]
    );

    request.json(200, R::ok(ctx))
}

pub async fn to_datetime_string(
    query: web::Form<HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    let timestamp_value_str = query
        .get("timestamp_value")
        .ok_or_else(|| Error::invalid_request("Missing form data field: timestamp_value"))?;

    let datetime_zone = query
        .get("datetime_zone2")
        .ok_or_else(|| Error::invalid_request("Missing form data field: datetime_zone2"))?;

    let timestamp_value = crate::commons::string_to_number::<i64>(timestamp_value_str)?;

    let naive = DateTime::from_timestamp_millis(timestamp_value).unwrap();

    let tz: chrono_tz::Tz = datetime_zone.parse().unwrap();
    let offset = tz.offset_from_utc_datetime(&Utc::now().naive_utc());

    let offset_count: i32 = offset.fix().local_minus_utc() / 3600;
    let datetime_tz: DateTime<chrono_tz::Tz> = tz.from_utc_datetime(&naive.naive_utc());
    let date_string: String = datetime_tz.format("%Y-%m-%dT%H:%M:%S.%3fZ").to_string();

    let datetime_string_rfc3339 = if date_string.ends_with('Z') && offset_count != 0 {
        let s = &date_string.replace('Z', "");

        if offset_count > 0 {
            format!("{}+{:02}:00", s, offset_count)
        } else {
            format!("{}-{:02}:00", s, offset_count.abs())
        }
    } else {
        date_string.to_string()
    };

    request.json(200, R::ok(datetime_string_rfc3339))
}

pub async fn parse_datetime_string_to_millis(
    query: web::Form<HashMap<String, String>>,
    request: HttpRequest,
) -> impl Responder {
    // 将日期时间字符串解析为 DateTime<FixedOffset>
    // "2024-02-07T20:15:05.473+08:00"
    // "2024-02-07T20:15:05.473+00:00"
    // "2024-02-07T20:15:05.473Z"
    let datetime_string = query
        .get("datetime_string")
        .ok_or_else(|| Error::invalid_request("Missing form data field: datetime_string"))?;

    let datetime_string = if datetime_string.ends_with('Z') {
        format!("{}+00:00", datetime_string.replace('Z', ""))
    } else {
        datetime_string.to_string()
    };

    let local_time = chrono::DateTime::parse_from_rfc3339(&datetime_string).unwrap();
    let naive_date_time = local_time.with_timezone(&Utc).naive_local();
    let datetime_utc = DateTime::<Utc>::from_naive_utc_and_offset(naive_date_time, Utc);
    let timestamp_millis: i64 = datetime_utc.timestamp_millis();

    request.json(200, R::ok(timestamp_millis))
}

pub async fn convert_to_unicode_escape(data: web::Bytes, request: HttpRequest) -> impl Responder {
    let data = crate::commons::bytes_to_string(data.to_vec())?;

    let s = lazy_regex::regex_replace_all!(r#"\\u([0-9a-zA-Z]{4})"#, &data, |_, num: &str| {
        let num: u32 = u32::from_str_radix(num, 16).unwrap();
        let c: char = std::char::from_u32(num).unwrap();
        c.to_string()
    });

    request.text(200, s.as_ref())
}

pub async fn format_jsonstring(data: web::Bytes, request: HttpRequest) -> impl Responder {
    let data = crate::commons::bytes_to_string(data.to_vec())?;

    let result = formatjson::format_json(&data).map_err(|e| anyhow::anyhow!(e))?;

    request.text(200, &result)
}