✨ added yahoo finance fetcher for bin-app

Author: Julien-R44

src/bin/cli/get_args.rs

@@ -1,49 +1,40 @@
 use clap::{App, Arg};
-use std::str::FromStr;
 
-pub enum ReadingMode {
+#[derive(PartialEq)]
+pub enum CandlesRetrievalMode {
     Stdin,
     CsvFile,
-}
-
-impl FromStr for ReadingMode {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "Stdin" => Ok(ReadingMode::Stdin),
-            "CsvFile" => Ok(ReadingMode::CsvFile),
-            _ => Err("no match"),
-        }
-    }
+    Yahoo,
 }
 
 pub struct CliOptions {
-    pub reading_mode: ReadingMode,
+    pub mode: CandlesRetrievalMode,
     pub file_path: Option<String>,
     pub chart_name: Option<String>,
     pub bear_color: Option<String>,
     pub bull_color: Option<String>,
+    pub ticker: Option<String>,
+    pub interval: String,
 }
 
 pub fn get_args() -> CliOptions {
     let matches = App::new(env!("CARGO_PKG_NAME"))
         .version(env!("CARGO_PKG_VERSION"))
         .author(env!("CARGO_PKG_AUTHORS"))
         .arg(
-            Arg::with_name("READING_MODE")
-                .short("r")
-                .long("reading-mode")
-                .help("Make the program reads and parse candles from stdin.")
-                .possible_values(&["stdin", "csv-file", "json-file"])
+            Arg::with_name("MODE")
+                .short("m")
+                .long("mode")
+                .help("Select the method for retrieving the candles.")
+                .possible_values(&["stdin", "csv-file", "json-file", "yahoo-fetch"])
                 .takes_value(true)
                 .required(true),
         )
         .arg(
             Arg::with_name("FILE")
                 .short("f")
                 .long("file")
-                .help("File to read candles from, if reading-mode is `*-file.`")
+                .help("[MODE:*-file] File to read candles from.`")
                 .takes_value(true),
         )
         .arg(
@@ -64,14 +55,35 @@ pub fn get_args() -> CliOptions {
                 .help("Sets the ascending candles color in hexadecimal.")
                 .takes_value(true),
         )
+        .arg(
+            Arg::with_name("TICKER")
+                .long("ticker")
+                .takes_value(true)
+                .required_if("MODE", "yahoo-fetch")
+                .help("[MODE:*-fetch] The broker-side ticker of the asset you want to plot."),
+        )
+        .arg(
+            Arg::with_name("INTERVAL")
+                .long("interval")
+                .default_value("1d")
+                .possible_values(&[
+                    "1m", "2m", "5m", "15m", "30m", "60m", "90m", "1h", "1d", "5d", "1wk", "1mo",
+                    "3mo",
+                ])
+                .takes_value(true)
+                .help("[MODE:*-fetch] The interval you want to retrieve the candles from the API"),
+        )
         .get_matches();
 
     return CliOptions {
-        reading_mode: match matches.value_of("READING_MODE").unwrap() {
-            "stdin" => ReadingMode::Stdin,
-            "csv-file" => ReadingMode::CsvFile,
+        mode: match matches.value_of("MODE").unwrap() {
+            "stdin" => CandlesRetrievalMode::Stdin,
+            "csv-file" => CandlesRetrievalMode::CsvFile,
+            "yahoo-fetch" => CandlesRetrievalMode::Yahoo,
             _ => panic!("Invalid reading mode."),
         },
+        interval: matches.value_of("INTERVAL").unwrap().to_string(),
+        ticker: matches.value_of("TICKER").map(|s| s.to_string()),
         file_path: matches.value_of("FILE").map(|s| s.to_string()),
         chart_name: matches.value_of("CHART_NAME").map(|s| s.to_string()),
         bear_color: matches.value_of("BEAR_COLOR").map(|s| s.to_string()),

src/bin/cli/main.rs

@@ -1,4 +1,3 @@
-use clap::{App, Arg};
 use cli_candlestick_chart::{Candle, Chart};
 use std::error::Error;
 use std::io::{self, BufRead};
@@ -7,7 +6,10 @@ mod utils;
 use utils::hexa_to_rgb;
 
 mod get_args;
-use get_args::{get_args, ReadingMode};
+use get_args::{get_args, CandlesRetrievalMode};
+
+mod yahoo_api;
+use yahoo_api::get_yahoo_klines;
 
 fn parse_candles_from_stdin() -> Vec<Candle> {
     let stdin = io::stdin();
@@ -38,18 +40,25 @@ fn main() {
     let options = get_args();
     let mut candles: Vec<Candle> = Vec::new();
 
-    match options.reading_mode {
-        ReadingMode::Stdin => {
+    match options.mode {
+        CandlesRetrievalMode::Stdin => {
             candles = parse_candles_from_stdin();
         }
-        ReadingMode::CsvFile => {
+        CandlesRetrievalMode::CsvFile => {
             let filepath = options.file_path.expect("No file path provided.");
             candles = parse_candles_from_csv(&filepath).unwrap();
         }
+        CandlesRetrievalMode::Yahoo => {
+            candles = get_yahoo_klines(&options.ticker.to_owned().unwrap(), &options.interval);
+        }
     };
 
     let mut chart = Chart::new(&candles);
 
+    if !options.ticker.is_none() && options.mode == CandlesRetrievalMode::Yahoo {
+        chart.set_name(options.ticker.unwrap().to_string());
+    }
+
     if let Some(chart_name) = options.chart_name {
         chart.set_name(chart_name);
     }

src/bin/cli/yahoo_api.rs

@@ -0,0 +1,61 @@
+use cli_candlestick_chart::Candle;
+
+pub fn get_range_from_interval(interval: &str) -> String {
+    let output = match interval {
+        "1m" => "1d",
+        "2m" => "1d",
+        "5m" => "1d",
+        "15m" => "5d",
+        "30m" => "5d",
+        "60m" => "5d",
+        "90m" => "5d",
+        "1h" => "1mo",
+        "1d" => "1y",
+        "5d" => "1y",
+        "1wk" => "1y",
+        "1mo" => "1y",
+        "3mo" => "1y",
+        _ => panic!("Invalid interval"),
+    };
+
+    output.to_owned()
+}
+
+pub fn get_yahoo_klines(symbol: &str, interval: &str) -> Vec<Candle> {
+    let base_url = "https://query1.finance.yahoo.com";
+
+    let range = get_range_from_interval(interval);
+
+    let url = format!(
+        "{}/v8/finance/chart/{}?range={}&interval={}",
+        base_url, symbol, range, interval
+    );
+
+    let client = reqwest::blocking::get(url.as_str()).unwrap();
+    let value: serde_json::Value = serde_json::from_str(client.text().unwrap().as_str()).unwrap();
+
+    let nb_candles = value["chart"]["result"][0]["timestamp"]
+        .as_array()
+        .expect("Ticker seems to be invalid.")
+        .len();
+
+    let mut candles: Vec<Candle> = Vec::new();
+    for i in 0..nb_candles {
+        let base = &value["chart"]["result"][0]["indicators"]["quote"][0];
+
+        let open = base["open"][i].as_f64().unwrap();
+        let high = base["high"][i].as_f64().unwrap();
+        let low = base["low"][i].as_f64().unwrap();
+        let close = base["close"][i].as_f64().unwrap();
+
+        let candle = Candle::new(
+            open.to_owned(),
+            high.to_owned(),
+            low.to_owned(),
+            close.to_owned(),
+        );
+        candles.push(candle);
+    }
+
+    candles
+}