加入trades。

README.MD

@@ -1,6 +1,6 @@
 ## /ia/get_indicator  生成指标
 
-### MSV指标
+### 1. MSV指标
 ##### 毫秒(millisecond)波动率(volatility)
 ``` json
 {
@@ -28,3 +28,35 @@
     },
 }
 ```
+
+### 2. Trades数据
+``` json
+{
+    "indicator": "trades",                  // 指标名
+    "query": {                              // 查询结构
+        "exchange": "gate_usdt_swap",       // 交易所，当前支持[gate_usdt_swap, bitget_usdt_swap]
+        "symbol": "btc",                    // 符号，支持大小写，如果不写usdt会自动在后面添加_USDT
+        "start_time_mills": "0",            // 开始时间（毫秒级）
+        "end_time_mills": "0"               // 结束时间（毫秒级）
+    }
+}
+```
+
+
+##### response
+``` json
+{
+    "query": {},                            // 你的查询参数，用于接口联调       
+    "message": "hello",                     // 后台提醒
+    "code": 200,                            // 200 就是对的
+    "data": [
+        {
+            "id": "27798449",               // trade id，交易所返的
+            "price": "0.4921",              // 交易价格
+            "size": "1",                    // 交易数量，负数是卖出
+            "time": "1713407058504"         // 成交时间戳
+        },
+        ...
+    ],
+}
+```

src/main.rs

@@ -2,6 +2,8 @@ mod control_c;
 mod server;
 pub mod db_connector;
 mod msv;
+mod trades;
+mod params_utils;
 
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};

src/msv.rs

@@ -4,9 +4,11 @@ use std::str::FromStr;
 use actix_web::{HttpResponse};
 use chrono::Utc;
 use rust_decimal::Decimal;
+use rust_decimal::prelude::ToPrimitive;
 use rust_decimal_macros::dec;
 use serde_json::{json, Value};
 use crate::db_connector::get_trades_json;
+use crate::params_utils::{get_str, parse_str_to_decimal};
 use crate::server::{Response, Trade};
 
 pub fn symbol_fix(symbol: &str) -> String {
@@ -22,68 +24,36 @@ pub fn symbol_fix(symbol: &str) -> String {
 // 将trades_json转换为指标
 pub async fn generate_msv(query_value: Value) -> HttpResponse {
     // 参数处理
-    let exchange = match query_value["exchange"].as_str() {
-        None => {
-            "gate_usdt_swap"
+    let exchange = match get_str(query_value.clone(), "exchange") {
+        Ok(str) => {
+            str
         }
-        Some(exchange) => {
-            if exchange.is_empty() {
-                "gate_usdt_swap"
-            } else {
-                exchange
-            }
+        Err(response) => {
+            return response
         }
     };
-    let symbol = match query_value["symbol"].as_str() {
-        None => {
-            "BTC_USDT".to_string()
+    let symbol = match get_str(query_value.clone(), "symbol") {
+        Ok(symbol) => {
+            symbol_fix(symbol.as_str())
         }
-        Some(symbol) => {
-            if symbol.is_empty() {
-                "BTC_USDT".to_string()
-            } else {
-                symbol_fix(symbol)
-            }
+        Err(response) => {
+            return response
         }
     };
-    let mills_back = match query_value["mills_back"].as_str() {
-        None => {
-            dec!(37)
+    let mills_back = match parse_str_to_decimal(query_value.clone(), "mills_back") {
+        Ok(t) => {
+            t
         }
-        Some(mills_back_str) => {
-            if mills_back_str.is_empty() {
-                dec!(37)
-            } else {
-                Decimal::from_str(mills_back_str).unwrap()
-            }
+        Err(response) => {
+            return response
         }
     };
-    let minute_time_range = match query_value["minute_time_range"].as_str() {
-        None => {
-            240
+    let minute_time_range = match parse_str_to_decimal(query_value.clone(), "minute_time_range") {
+        Ok(t) => {
+            t.to_i64().unwrap()
         }
-        Some(minute_time_range_str) => {
-            if minute_time_range_str.is_empty() {
-                240
-            } else {
-                match i64::from_str(minute_time_range_str) {
-                    Ok(minute_time_range) => {
-                        minute_time_range
-                    }
-                    Err(_) => {
-                        // 返回数据
-                        let response = Response {
-                            query: query_value.clone(),
-                            msg: Some("时间不要字符串，要数字，这个版本不支持字符串".to_string()),
-                            code: 500,
-                            data: Value::Null,
-                        };
-
-                        let json_string = serde_json::to_string(&response).unwrap();
-                        return HttpResponse::Ok().content_type("application/json").body(json_string)
-                    }
-                }
-            }
+        Err(response) => {
+            return response
         }
     };
 
@@ -91,7 +61,7 @@ pub async fn generate_msv(query_value: Value) -> HttpResponse {
     let end_time = Utc::now().timestamp_millis();
     let start_time = end_time - minute_time_range * 60 * 1000;
     let db_response = get_trades_json(
-        exchange,
+        exchange.as_str(),
         symbol.as_str(),
         start_time,
         end_time,
@@ -116,7 +86,7 @@ pub async fn generate_msv(query_value: Value) -> HttpResponse {
         HttpResponse::Ok().content_type("application/json").body(json_string)
     } else {
         let json_string = serde_json::to_string(&db_response).unwrap();
-        HttpResponse::BadRequest().content_type("application/json").body(json_string)
+        HttpResponse::Ok().content_type("application/json").body(json_string)
     }
 }
 

src/params_utils.rs

@@ -0,0 +1,78 @@
+use std::str::FromStr;
+use actix_web::HttpResponse;
+use rust_decimal::{Decimal};
+use serde_json::Value;
+use crate::server::Response;
+
+pub fn parse_str_to_decimal(value: Value, param_name: &str) -> Result<Decimal, HttpResponse> {
+    match get_str(value.clone(), param_name) {
+        Ok(decimal_str) => {
+            match Decimal::from_str(decimal_str.as_str()) {
+                Ok(rst) => {
+                    Ok(rst)
+                }
+                Err(_) => {
+                    // 返回数据
+                    let response = Response {
+                        query: value.clone(),
+                        msg: Some(format!("{}你传的怕不是个数字啊 你传的是: {}", param_name, value[param_name])),
+                        code: 500,
+                        data: Value::Null,
+                    };
+
+                    let json_string = serde_json::to_string(&response).unwrap();
+                    Err(HttpResponse::Ok().content_type("application/json").body(json_string))
+                }
+            }
+        }
+        Err(response) => {
+            Err(response)
+        }
+    }
+}
+
+pub fn get_str(value: Value, param_name: &str) -> Result<String, HttpResponse> {
+    match value[param_name].as_str() {
+        None => {
+            // 返回数据
+            let response = Response {
+                query: value.clone(),
+                msg: Some(format!("{}是必填项, 你的参数: {}", param_name, value.to_string())),
+                code: 500,
+                data: Value::Null,
+            };
+
+            let json_string = serde_json::to_string(&response).unwrap();
+            Err(HttpResponse::Ok().content_type("application/json").body(json_string))
+        }
+        Some(str) => {
+            if str.is_empty() {
+                // 返回数据
+                let response = Response {
+                    query: value.clone(),
+                    msg: Some(format!("{}传了个空字符串", param_name)),
+                    code: 500,
+                    data: Value::Null,
+                };
+
+                let json_string = serde_json::to_string(&response).unwrap();
+                Err(HttpResponse::Ok().content_type("application/json").body(json_string))
+            } else {
+                Ok(str.to_string())
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_decimal_to_i64() {
+    use global::log_utils::init_log_with_info;
+    use tracing::info;
+    use rust_decimal_macros::dec;
+    use rust_decimal::prelude::ToPrimitive;
+
+    init_log_with_info();
+
+    info!("{}", dec!(50).to_i64().unwrap());
+    info!("{}", dec!(50.5).to_i64().unwrap());
+}

src/server.rs

@@ -7,8 +7,9 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tracing::{info};
 use crate::msv::generate_msv;
+use crate::trades::generate_trades;
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct Response {
     pub msg: Option<String>,
     pub query: Value,
@@ -63,6 +64,9 @@ async fn get_indicator(query: web::Json<Value>) -> impl Responder {
         "msv" => {
             generate_msv(query.into_inner().get("query").unwrap().clone()).await
         },
+        "trades" => {
+            generate_trades(query.into_inner().get("query").unwrap().clone()).await
+        },
         _ => {
             let query_json = query.into_inner().clone();
             let response = Response {

src/trades.rs

@@ -0,0 +1,65 @@
+use actix_web::HttpResponse;
+use rust_decimal::prelude::ToPrimitive;
+use serde_json::Value;
+use crate::db_connector::get_trades_json;
+use crate::msv::{parse_json_to_trades, symbol_fix};
+use crate::params_utils::{get_str, parse_str_to_decimal};
+use crate::server::Response;
+
+pub async fn generate_trades(query_value: Value) -> HttpResponse {
+    // 参数处理
+    let exchange = match get_str(query_value.clone(), "exchange") {
+        Ok(str) => {
+            str
+        }
+        Err(response) => {
+            return response
+        }
+    };
+    let symbol = match get_str(query_value.clone(), "symbol") {
+        Ok(symbol) => {
+            symbol_fix(symbol.as_str())
+        }
+        Err(response) => {
+            return response
+        }
+    };
+    let start_time = match parse_str_to_decimal(query_value.clone(), "start_time_mills") {
+        Ok(t) => {
+            t.to_i64().unwrap()
+        }
+        Err(response) => {
+            return response
+        }
+    };
+    let end_time = match parse_str_to_decimal(query_value.clone(), "end_time_mills") {
+        Ok(t) => {
+            t.to_i64().unwrap()
+        }
+        Err(response) => {
+            return response
+        }
+    };
+
+    let db_response = get_trades_json(exchange.as_str(), symbol.as_str(), start_time, end_time).await;
+
+    // 对数据库返回的数据进行容错处理
+    if db_response.code == 200 {
+        // 数据本地化处理
+        let trades = parse_json_to_trades(db_response.data);
+
+        // trades数据获取完毕
+        let response = Response {
+            query: query_value.clone(),
+            msg: Some("trades获取完毕".to_string()),
+            code: 200,
+            data: serde_json::to_value(trades).unwrap()
+        };
+
+        let json_string = serde_json::to_string(&response).unwrap();
+        HttpResponse::Ok().content_type("application/json").body(json_string)
+    } else {
+        let json_string = serde_json::to_string(&db_response).unwrap();
+        HttpResponse::BadRequest().content_type("application/json").body(json_string)
+    }
+}