working

src/download/jpmaqsdownload.rs

@@ -0,0 +1,94 @@
+use crate::download::oauth_client::OAuthClient;
+use crate::download::requester::DQRequester;
+use crate::download::requester::DQTimeseriesRequestArgs;
+use crate::download::timeseries::DQTimeSeriesResponse;
+use crate::download::timeseries::JPMaQSIndicator;
+use std::error::Error;
+
+const DEFAULT_JPMAQS_METRICS: [&str; 4] = ["value", "grading", "eop_lag", "mop_lag"];
+
+fn ticker_to_expressions(ticker: &str) -> Vec<String> {
+    DEFAULT_JPMAQS_METRICS
+        .iter()
+        .map(|metric| format!("DB(JPMAQS,{},{})", ticker, metric))
+        .collect::<Vec<String>>()
+}
+
+fn construct_expressions(tickers: Vec<String>) -> Vec<String> {
+    tickers
+        .iter()
+        .flat_map(|ticker| ticker_to_expressions(ticker))
+        .collect()
+}
+
+fn is_jpmaq_expression(expression: &str) -> bool {
+    expression.starts_with("DB(JPMAQS,")
+        && expression.ends_with(")")
+        && expression.split(',').count() == 3
+        && expression.split(',').nth(0).unwrap() == "DB(JPMAQS"
+        && expression.split(',').nth(2).unwrap().ends_with(")")
+}
+
+fn all_jpmaq_expressions(expressions: Vec<String>) -> bool {
+    expressions
+        .iter()
+        .all(|expression| is_jpmaq_expression(expression))
+}
+
+#[derive(Debug, Clone)]
+pub struct JPMaQSDownload {
+    requester: DQRequester,
+}
+
+impl Default for JPMaQSDownload {
+    fn default() -> Self {
+        let requester = DQRequester::default();
+        JPMaQSDownload { requester }
+    }
+}
+
+impl JPMaQSDownload {
+    pub fn new(client_id: String, client_secret: String) -> Self {
+        let oauth_client = OAuthClient::new(client_id.clone(), client_secret.clone());
+        let requester = DQRequester::new(oauth_client);
+        JPMaQSDownload { requester }
+    }
+
+    pub fn check_connection(&mut self) -> Result<(), Box<dyn Error>> {
+        self.requester.check_connection()
+    }
+
+    pub fn get_catalogue(&mut self) -> Result<Vec<String>, Box<dyn Error>> {
+        let dq_catalogue = self.requester.get_catalogue("JPMAQS", 1000)?;
+        Ok(dq_catalogue.all_instruments)
+    }
+
+    pub fn get_expressions(
+        &mut self,
+        expressions: Vec<String>,
+    ) -> Result<Vec<DQTimeSeriesResponse>, Box<dyn Error>> {
+        let dqts_vec = self.requester.get_timeseries(DQTimeseriesRequestArgs {
+            expressions: expressions,
+            ..Default::default()
+        })?;
+
+        Ok(dqts_vec)
+    }
+
+    pub fn get_indicators(
+        &mut self,
+        tickers: Vec<String>,
+    ) -> Result<Vec<JPMaQSIndicator>, Box<dyn Error>> {
+        let expressions = construct_expressions(tickers);
+        assert!(all_jpmaq_expressions(expressions.clone()));
+        let dqts_vec = self.get_expressions(expressions)?;
+
+        let indicators = dqts_vec
+            .iter()
+            .flat_map(|dqts| dqts.get_timeseries_by_ticker())
+            .map(|tsv| JPMaQSIndicator::new(tsv))
+            .collect::<Result<Vec<JPMaQSIndicator>, Box<dyn Error>>>()?;
+
+        Ok(indicators)
+    }
+}