taikoothong/src/main.rs

#![feature(proc_macro_hygiene, decl_macro)]


use anyhow; // Exception Handling
use chrono::{TimeZone, Utc};
use curl::easy::Easy;
use serde_json::{Result, Value}; // JSON
use std::collections::HashMap;
use serde_json::Value::Array;
use rocket_dyn_templates::Template;
use rocket::{Rocket, Build};
use round::round;
use num_format::{Locale, WriteFormatted};

#[macro_use] extern crate rocket;

enum Date {
    Day(u8),
    Week(u8),
    Month(u8),
    Max,
    YearToDate}


impl Date {
    fn as_str(&self) -> String {
        match &self {
            Date::Day(d) => format!("{:?}d", d),
            Date::Week(wk) => format!("{:?}wk", wk),
            Date::Month(mo) => format!("{:?}mo", mo),
            Date::YearToDate => format!("ytd"),
            Date::Max => format!("max"),
        }
    }
}



#[get("/<stock_id>")]
fn get_tw_stock(stock_id: String) -> Template {
    // let a = "👋 Hello, stock no: a22";

    let response_body = get_stock_data(stock_id.as_str(), Date::Day(1), Date::Day(5));
    let response_json: Value = serde_json::from_str(response_body.as_str()).unwrap();

    let days_in_unix_time = &response_json["chart"]["result"][0]["timestamp"];

    let mut stock_total_data = HashMap::new();

    let days_in_custom_format = match days_in_unix_time {
        serde_json::Value::Array(days_vec) => days_vec
            .iter()
            .map(|day|json_unix_time_to_date(day))
            .collect::<Vec<_>>(),
        _ => vec![format!("Not a series of date")],
    };

    println!("{:?}", &days_in_unix_time);

    stock_total_data.insert("date",  days_in_custom_format);

    let mut open_prices : Vec<String> = vec![];
    let mut close_prices : Vec<String> = vec![];
    let mut high_prices : Vec<String> = vec![];
    let mut low_prices : Vec<String> = vec![];
    let mut volumes : Vec<String> = vec![];


    let price_and_volume_infos = &response_json["chart"]["result"][0]["indicators"]["quote"][0];
    
    let open_prices_orig = &price_and_volume_infos["open"];
    let close_prices_orig = &price_and_volume_infos["close"];
    let high_prices_orig = &price_and_volume_infos["high"];
    let low_prices_orig = &price_and_volume_infos["low"];
    let volumes_orig = &price_and_volume_infos["volume"];


    match (open_prices_orig, close_prices_orig, high_prices_orig, low_prices_orig, volumes_orig){
        (Array(o), Array(c), Array(h),
            Array(l), Array(v)) => {
            for i in 0..(o.len()){
                open_prices.push(format!("{:0.2}", o[i].as_f64().unwrap()));
                close_prices.push(format!("{:0.2}", c[i].as_f64().unwrap()));
                high_prices.push(format!("{:0.2}", h[i].as_f64().unwrap()));
                low_prices.push(format!("{:0.2}", l[i].as_f64().unwrap()));
                let mut formatted_volume = String::new();
                formatted_volume.write_formatted(&v[i].as_i64().unwrap(), &Locale::zh);

                volumes.push(formatted_volume);
            }
            
        },
        _ => (),
    }

    stock_total_data.insert("open", open_prices);
    stock_total_data.insert("close", close_prices);
    stock_total_data.insert("high", high_prices);
    stock_total_data.insert("low", low_prices);
    stock_total_data.insert("volume", volumes);


    let mut stock_total_data_by_date = transverse_stock_data_by_date(stock_total_data.clone());
    //let mut stock_total_data_by_date_wrapper = HashMap::new();

    //stock_total_data_by_date_wrapper.insert("data", stock_total_data_by_date);

    //println!("{:?}", stock_total_data_by_date_wrapper);
    println!("{:?}", stock_total_data);
    return Template::render("tw_stock", stock_total_data);
}

fn json_unix_time_to_date(json_value: &Value) -> String {
    let unix_time = json_value.as_i64().unwrap();
    println!("{:?}", unix_time);

    let naive_time = Utc.timestamp_opt(unix_time, 0).unwrap();

    let date = format!("{}", naive_time.format("%Y-%m-%d"));
    println!("{:?}", date);

    return date;
}

fn transverse_stock_data_by_date(orig_data : HashMap<&str, Vec<String>>) -> 
    Vec<HashMap<String, String>>{
    let mut stock_data_by_date = vec![];
    let dates = &orig_data["date"];

    for i in 0..dates.len()-1{
        let mut day_hash_map = HashMap::new();
        day_hash_map.insert(format!("date"), orig_data["date"][i].clone());
        day_hash_map.insert(format!("open"), orig_data["open"][i].clone());
        day_hash_map.insert(format!("close"), orig_data["close"][i].clone());
        day_hash_map.insert(format!("high"), orig_data["high"][i].clone());
        day_hash_map.insert(format!("low"), orig_data["low"][i].clone());
        day_hash_map.insert(format!("volume"), orig_data["volume"][i].clone());

        stock_data_by_date.push(day_hash_map);

    }

    return stock_data_by_date;


}


fn get_stock_data(stock_id: &str, interval: Date, range: Date) -> String {
    let intrval_str = interval.as_str();
    let range_str = range.as_str();

    let url = format!(
        "https://query1.finance.yahoo.com/v8/finance/chart/\
        {:}.TW?metrics=Date,High,Low,Open,Close,Volume&interval={:}&range={:}",
        stock_id, intrval_str, range_str
    );

    let mut curl_easy = Easy::new(); // fetch the data with the curl binding
    let mut response = String::new();

    {
        curl_easy.url(url.as_str()).unwrap();

        let mut curl_transfer = curl_easy.transfer();

        curl_transfer
            .write_function(|data| {
                response.push_str(std::str::from_utf8(data).unwrap());
                Ok(data.len())
            })
            .unwrap();

        curl_transfer.perform().unwrap();
    }

    let response_returned = response.clone();

    return response_returned;
}


#[launch]
fn rocket() -> Rocket<Build>  {
    // rocket::ignite().mount("/", routes![index]).launch();
    rocket::build().attach(Template::fairing())
        .mount("/tw", routes![get_tw_stock])


}