678 lines
28 KiB
Rust
678 lines
28 KiB
Rust
use crate::coex::exchange_team::*;
|
|
use crate::coex::order_team::*;
|
|
use csv::{DeserializeRecordsIter, StringRecord};
|
|
use rust_decimal::prelude::ToPrimitive;
|
|
use rust_decimal::Decimal;
|
|
use serde::Deserialize;
|
|
|
|
// use super::strategy_test;
|
|
use super::{
|
|
exists_record, insert_one_record, try_join_all, try_select_record, AllData, ExchangeInfo,
|
|
FilteredDataValue, FromRow, HashMap, RealtimePriceData, TradeFee,
|
|
};
|
|
use crate::signal_association::signal_decision::*;
|
|
use tokio::time::{sleep, Duration, Instant};
|
|
|
|
#[derive(Debug, FromRow)]
|
|
struct ServerEpoch {
|
|
server_epoch: u64,
|
|
}
|
|
|
|
#[derive(Debug, FromRow)]
|
|
struct Record {
|
|
symbol: String,
|
|
suggested_price: Decimal,
|
|
close_time: u64,
|
|
registered_server_epoch: u64,
|
|
registerer: u16,
|
|
is_long: u8,
|
|
}
|
|
|
|
pub async fn execute_list_up_for_buy(
|
|
all_data: &AllData,
|
|
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
// crate::strategy_team::strategy_001::list_up_for_buy(all_data).await;
|
|
// crate::strategy_team::strategy_002::list_up_for_buy(all_data).await;
|
|
// crate::strategy_team::strategy_003::list_up_for_buy(all_data).await;
|
|
// crate::strategy_team::strategy_004::list_up_for_buy(all_data).await;
|
|
// crate::strategy_team::strategy_005::list_up_for_buy(all_data).await;
|
|
crate::strategy_team::strategy_006::list_up_for_buy(all_data).await;
|
|
crate::strategy_team::strategy_007::list_up_for_buy(all_data).await;
|
|
crate::strategy_team::strategy_008::list_up_for_buy(all_data).await;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn execute_list_up_for_sell(
|
|
all_data: &AllData,
|
|
exchange_info_map: &HashMap<String, ExchangeInfo>,
|
|
trade_fee_map: &HashMap<String, TradeFee>,
|
|
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
// crate::strategy_team::strategy_001::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
|
|
// crate::strategy_team::strategy_002::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
|
|
// crate::strategy_team::strategy_003::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
|
|
// crate::strategy_team::strategy_004::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
|
|
// crate::strategy_team::strategy_005::list_up_for_sell(&all_data, &exchange_info_map, &trade_fee_map).await;
|
|
crate::strategy_team::strategy_006::list_up_for_sell(
|
|
&all_data,
|
|
&exchange_info_map,
|
|
&trade_fee_map,
|
|
)
|
|
.await;
|
|
crate::strategy_team::strategy_007::list_up_for_sell(
|
|
&all_data,
|
|
&exchange_info_map,
|
|
&trade_fee_map,
|
|
)
|
|
.await;
|
|
crate::strategy_team::strategy_008::list_up_for_sell(
|
|
&all_data,
|
|
&exchange_info_map,
|
|
&trade_fee_map,
|
|
)
|
|
.await;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn insert_pre_suggested_coins(
|
|
registerer: i32,
|
|
is_long: bool,
|
|
filtered_coins: &HashMap<String, FilteredDataValue>,
|
|
alldata: &AllData,
|
|
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
// Check the existance of record that is registered by this strategist
|
|
let mut dest_table_name = String::from("suggested_coin_list");
|
|
let mut dest2_table_name = String::from("buy_ordered_coin_list");
|
|
let mut dest3_table_name = String::from("pre_suggested_coin_list");
|
|
let mut insert_table_name = String::from("pre_suggested_coin_list");
|
|
let mut exists_condition_build = String::from("registerer=");
|
|
exists_condition_build.push_str(registerer.to_string().as_str());
|
|
let mut exists_condition = Some(exists_condition_build);
|
|
let exists_result1 = exists_record(&dest_table_name, &exists_condition).await;
|
|
let exists_result2 = exists_record(&dest2_table_name, &exists_condition).await;
|
|
let exists_result3 = exists_record(&dest3_table_name, &exists_condition).await;
|
|
let insert_columns = vec![
|
|
"symbol",
|
|
"close_time",
|
|
"suggested_price",
|
|
"current_price",
|
|
"stoploss",
|
|
"target_price",
|
|
"registered_server_epoch",
|
|
"profit_percent",
|
|
"minimum_profit_percent",
|
|
"maximum_profit_percent",
|
|
"registerer",
|
|
"is_long",
|
|
];
|
|
|
|
if exists_result1 == true && exists_result2 == true && exists_result3 == true {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
#[derive(FromRow)]
|
|
struct SelectData2 {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let mut select_columns2 = String::from("symbol, close_time");
|
|
let select_data_structure2 = SelectData2 {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let suggested_coin_list = try_select_record(
|
|
&dest_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
let ordered_coin_list = try_select_record(
|
|
&dest2_table_name,
|
|
&select_columns2,
|
|
&select_condition,
|
|
&select_data_structure2,
|
|
)
|
|
.await?;
|
|
let pre_suggested_coin_list = try_select_record(
|
|
&dest3_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for list_element in &ordered_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for list_element in &pre_suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else if exists_result1 == true && exists_result2 == true && exists_result3 == false {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
#[derive(FromRow)]
|
|
struct SelectData2 {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let mut select_columns2 = String::from("symbol, close_time");
|
|
let select_data_structure2 = SelectData2 {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let suggested_coin_list = try_select_record(
|
|
&dest_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
let ordered_coin_list = try_select_record(
|
|
&dest2_table_name,
|
|
&select_columns2,
|
|
&select_condition,
|
|
&select_data_structure2,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for list_element in &ordered_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else if exists_result1 == true && exists_result2 == false && exists_result3 == true {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let suggested_coin_list = try_select_record(
|
|
&dest_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
let pre_suggested_coin_list = try_select_record(
|
|
&dest3_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for list_element in &pre_suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else if exists_result1 == true && exists_result2 == false && exists_result3 == false {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let suggested_coin_list = try_select_record(
|
|
&dest_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else if exists_result1 == false && exists_result2 == true && exists_result3 == true {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
#[derive(FromRow)]
|
|
struct SelectData2 {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let mut select_columns2 = String::from("symbol, close_time");
|
|
let select_data_structure2 = SelectData2 {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let ordered_coin_list = try_select_record(
|
|
&dest2_table_name,
|
|
&select_columns2,
|
|
&select_condition,
|
|
&select_data_structure2,
|
|
)
|
|
.await?;
|
|
let pre_suggested_coin_list = try_select_record(
|
|
&dest3_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, close_time, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &ordered_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for list_element in &pre_suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else if exists_result1 == false && exists_result2 == true && exists_result3 == false {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
#[derive(FromRow)]
|
|
struct SelectData2 {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let mut select_columns2 = String::from("symbol, close_time");
|
|
let select_data_structure2 = SelectData2 {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let ordered_coin_list = try_select_record(
|
|
&dest2_table_name,
|
|
&select_columns2,
|
|
&select_condition,
|
|
&select_data_structure2,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &ordered_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else if exists_result1 == false && exists_result2 == false && exists_result3 == true {
|
|
// Bring the current list of pre-suggested coins from [pre_suggested_coin_list] and [ordered_coin_list]
|
|
#[derive(FromRow)]
|
|
struct SelectData {
|
|
symbol: String,
|
|
close_time: i64,
|
|
}
|
|
let mut select_columns = String::from("symbol, close_time");
|
|
let mut condition_build = String::from("WHERE registerer=");
|
|
condition_build.push_str(registerer.to_string().as_str());
|
|
let select_condition = Some(condition_build);
|
|
let select_data_structure = SelectData {
|
|
symbol: String::new(),
|
|
close_time: 0,
|
|
};
|
|
let pre_suggested_coin_list = try_select_record(
|
|
&dest3_table_name,
|
|
&select_columns,
|
|
&select_condition,
|
|
&select_data_structure,
|
|
)
|
|
.await?;
|
|
|
|
// insert record without duplicate(registerer, closetime, symbol) into [pre_suggested_coin_list]
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut is_dupe = false; // initialize
|
|
|
|
for list_element in &pre_suggested_coin_list {
|
|
if (*symbol == list_element.symbol)
|
|
&& (filtered_data.closetime == list_element.close_time)
|
|
{
|
|
is_dupe = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if is_dupe == false {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
} else {
|
|
for (symbol, filtered_data) in filtered_coins {
|
|
let mut insert_values = vec![
|
|
symbol.clone(), // symbol
|
|
filtered_data.closetime.to_string(), // close_time
|
|
filtered_data.current_price.to_string(), // suggested_price
|
|
filtered_data.current_price.to_string(), // current_price
|
|
filtered_data.stoploss.to_string(), // stoploss
|
|
filtered_data.target_price.to_string(), // target_price
|
|
get_server_epoch().await.to_string(), // registered_server_epoch
|
|
0.0.to_string(), // profit_percent
|
|
0.0.to_string(), // minimum_profit_percent
|
|
0.0.to_string(), // maximum_profit_percent
|
|
registerer.to_string(), // registerer
|
|
];
|
|
|
|
if is_long == true {
|
|
insert_values.push(1.to_string()); // is_long
|
|
} else {
|
|
insert_values.push(0.to_string()); // is_long
|
|
}
|
|
|
|
insert_one_record(&insert_table_name, &insert_columns, &insert_values).await;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|