Add market data backfilling

Signed-off-by: Nikolaos Karaolidis <nick@karaolidis.com>

src/routes/assets.rs

@@ -0,0 +1,171 @@
+use crate::config::{
+    Config, ALPACA_ASSET_API_URL, ALPACA_CRYPTO_DATA_URL, ALPACA_STOCK_DATA_URL,
+    ALPACA_TIMESTAMP_FORMAT,
+};
+use crate::database;
+use crate::types::Class;
+use crate::types::{api::incoming, asset, Asset, BroadcastMessage, Status};
+use axum::{extract::Path, http::StatusCode, Extension, Json};
+use log::info;
+use serde::Deserialize;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tokio::sync::broadcast::Sender;
+
+pub async fn get_all(
+    Extension(app_config): Extension<Arc<Config>>,
+) -> Result<(StatusCode, Json<Vec<Asset>>), StatusCode> {
+    let assets = database::assets::select(&app_config.postgres_pool).await;
+    Ok((StatusCode::OK, Json(assets)))
+}
+
+pub async fn get(
+    Extension(app_config): Extension<Arc<Config>>,
+    Path(symbol): Path<String>,
+) -> Result<(StatusCode, Json<Asset>), StatusCode> {
+    let asset = database::assets::select_where_symbol(&app_config.postgres_pool, &symbol).await;
+    asset.map_or(Err(StatusCode::NOT_FOUND), |asset| {
+        Ok((StatusCode::OK, Json(asset)))
+    })
+}
+
+#[derive(Deserialize)]
+pub struct AddAssetRequest {
+    symbol: String,
+    trading: Option<bool>,
+}
+
+pub async fn add(
+    Extension(app_config): Extension<Arc<Config>>,
+    Extension(asset_broadcast_sender): Extension<Sender<BroadcastMessage>>,
+    Json(request): Json<AddAssetRequest>,
+) -> Result<(StatusCode, Json<Asset>), StatusCode> {
+    if database::assets::select_where_symbol(&app_config.postgres_pool, &request.symbol)
+        .await
+        .is_some()
+    {
+        return Err(StatusCode::CONFLICT);
+    }
+
+    app_config.alpaca_rate_limit.until_ready().await;
+    let asset = app_config
+        .alpaca_client
+        .get(&format!("{}/{}", ALPACA_ASSET_API_URL, request.symbol))
+        .send()
+        .await
+        .map_err(|e| match e.status() {
+            Some(StatusCode::NOT_FOUND) => StatusCode::NOT_FOUND,
+            _ => panic!(),
+        })?;
+
+    let asset = asset.json::<incoming::Asset>().await.unwrap();
+
+    if asset.status != Status::Active || !asset.tradable || !asset.fractionable {
+        return Err(StatusCode::FORBIDDEN);
+    }
+
+    let mut earliest_bar_request = app_config
+        .alpaca_client
+        .get(match asset.class {
+            Class::UsEquity => ALPACA_STOCK_DATA_URL,
+            Class::Crypto => ALPACA_CRYPTO_DATA_URL,
+        })
+        .query(&[
+            ("symbols", &asset.symbol),
+            ("timeframe", &String::from("1Min")),
+            (
+                "start",
+                &OffsetDateTime::UNIX_EPOCH
+                    .format(ALPACA_TIMESTAMP_FORMAT)
+                    .unwrap(),
+            ),
+            ("limit", &String::from("1")),
+        ]);
+
+    if asset.class == Class::UsEquity {
+        earliest_bar_request =
+            earliest_bar_request.query(&[("feed", &app_config.alpaca_source.to_string())]);
+    }
+
+    let earliest_bar = earliest_bar_request
+        .send()
+        .await
+        .unwrap()
+        .json::<incoming::bar::Message>()
+        .await
+        .unwrap();
+
+    let earliest_bar = earliest_bar
+        .bars
+        .get(&asset.symbol)
+        .ok_or(StatusCode::NOT_FOUND)?
+        .as_ref()
+        .ok_or(StatusCode::NOT_FOUND)?
+        .first()
+        .ok_or(StatusCode::NOT_FOUND)?;
+
+    let asset = Asset::from((
+        asset,
+        request.trading.unwrap_or(false),
+        earliest_bar.timestamp,
+    ));
+
+    database::assets::insert(&app_config.postgres_pool, &asset).await;
+
+    asset_broadcast_sender
+        .send(BroadcastMessage::Asset(asset::BroadcastMessage::Added(
+            asset.clone(),
+        )))
+        .unwrap();
+
+    info!("Added asset {}.", asset.symbol);
+    Ok((StatusCode::CREATED, Json(asset)))
+}
+
+#[allow(dead_code)]
+#[derive(Deserialize)]
+pub struct UpdateAssetRequest {
+    trading: bool,
+}
+
+pub async fn update(
+    Extension(app_config): Extension<Arc<Config>>,
+    Extension(asset_broadcast_sender): Extension<Sender<BroadcastMessage>>,
+    Path(symbol): Path<String>,
+    Json(request): Json<UpdateAssetRequest>,
+) -> Result<(StatusCode, Json<Asset>), StatusCode> {
+    let asset = database::assets::update_trading_where_symbol(
+        &app_config.postgres_pool,
+        &symbol,
+        &request.trading,
+    )
+    .await;
+
+    asset.map_or(Err(StatusCode::NOT_FOUND), |asset| {
+        asset_broadcast_sender
+            .send(BroadcastMessage::Asset(asset::BroadcastMessage::Updated(
+                asset.clone(),
+            )))
+            .unwrap();
+        info!("Updated asset {}.", symbol);
+        Ok((StatusCode::OK, Json(asset)))
+    })
+}
+
+pub async fn delete(
+    Extension(app_config): Extension<Arc<Config>>,
+    Extension(asset_broadcast_sender): Extension<Sender<BroadcastMessage>>,
+    Path(symbol): Path<String>,
+) -> Result<StatusCode, StatusCode> {
+    let asset = database::assets::delete_where_symbol(&app_config.postgres_pool, &symbol).await;
+
+    asset.map_or(Err(StatusCode::NOT_FOUND), |asset| {
+        asset_broadcast_sender
+            .send(BroadcastMessage::Asset(asset::BroadcastMessage::Deleted(
+                asset,
+            )))
+            .unwrap();
+        info!("Deleted asset {}.", symbol);
+        Ok(StatusCode::NO_CONTENT)
+    })
+}