stock-trek 0.4.3

Stock Trek time-series analysis
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::{
    error::{
        portfolio::PortfolioError,
        result::{StockTrekError, StockTrekResult},
    },
    portfolios::portfolio::{Portfolio, PortfolioTrait},
};
use digdigdig3::{Asset, ExchangeId};
use std::collections::HashMap;

pub struct InMemoryPortfolio {
    exchange_assets: HashMap<ExchangeId, Assets>,
}

struct Assets {
    tokens: HashMap<Asset, f64>,
}

impl Assets {
    fn new() -> Self {
        Self {
            tokens: HashMap::new(),
        }
    }
}

impl InMemoryPortfolio {
    pub fn new() -> Portfolio {
        Box::new(Self {
            exchange_assets: HashMap::new(),
        })
    }
    pub fn add_tokens(
        &mut self,
        exchange_id: ExchangeId,
        asset: Asset,
        quantity: f64,
    ) -> StockTrekResult<()> {
        let exchange = self
            .exchange_assets
            .entry(exchange_id)
            .or_insert(Assets::new());
        exchange
            .tokens
            .entry(asset)
            .and_modify(|previous| *previous += quantity)
            .or_insert(quantity);
        Ok(())
    }
    pub fn remove_tokens(
        &mut self,
        exchange_id: ExchangeId,
        asset: Asset,
        quantity: f64,
    ) -> StockTrekResult<()> {
        let exchange = self.exchange_assets.get_mut(&exchange_id).ok_or_else(|| {
            StockTrekError::Portfolio(PortfolioError::NoAccountInExchange {
                exchange: exchange_id.as_str().to_string(),
            })
        })?;
        let token_quantity = exchange.tokens.get_mut(&asset).ok_or_else(|| {
            StockTrekError::Portfolio(PortfolioError::AssetNotOwned {
                exchange: exchange_id.as_str().to_string(),
                asset: asset.clone(),
            })
        })?;
        if *token_quantity < quantity {
            return Err(StockTrekError::Portfolio(PortfolioError::NotEnoughTokens {
                exchange: exchange_id.as_str().to_string(),
                asset,
                tokens: *token_quantity,
                remove_request: quantity,
            }));
        }
        *token_quantity -= quantity;
        if *token_quantity == 0.0 {
            exchange.tokens.remove(&asset);
        }
        Ok(())
    }
}

impl PortfolioTrait for InMemoryPortfolio {
    fn has_account_in_exchange(&self, exchange: ExchangeId) -> bool {
        self.exchange_assets.contains_key(&exchange)
    }
    fn owns_asset(&self, asset: &Asset) -> bool {
        self.exchange_assets
            .values()
            .any(|assets| assets.tokens.contains_key(asset))
    }
    fn owns_asset_in_exchange(&self, asset: &Asset, exchange: &ExchangeId) -> bool {
        self.exchange_assets
            .get(exchange)
            .map(|assets| assets.tokens.contains_key(asset))
            .unwrap_or(false)
    }
    fn asset_total(&self, asset: Asset) -> f64 {
        self.exchange_assets
            .values()
            .map(|assets| assets.tokens.get(&asset).unwrap_or(&0.0))
            .sum()
    }
    fn asset_in_exchange(&self, asset: Asset, exchange: ExchangeId) -> f64 {
        self.exchange_assets
            .get(&exchange)
            .and_then(|assets| assets.tokens.get(&asset))
            .copied()
            .unwrap_or(0.0)
    }
}