use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::authentification::CredentialsOrApiKey;
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, deserialize_date, encode, ok, serialize_date};
pub use super::room::{PortfolioEntry, PortfolioRoom};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Asset {
Equity,
Crypto,
MoneyMarket,
Other,
}
impl Asset {
pub(crate) fn as_str(self) -> &'static str {
match self {
Asset::Equity => "EQUITY",
Asset::Crypto => "CRYPTO",
Asset::MoneyMarket => "MONEY_MARKET",
Asset::Other => "OTHER",
}
}
}
fn source<'de, D: serde::Deserializer<'de>>(
deserializer: D,
) -> std::result::Result<Option<String>, D::Error> {
Ok(Value::deserialize(deserializer)?
.as_str()
.filter(|source| !source.is_empty())
.map(str::to_string))
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Position {
pub id: String,
pub asset: Asset,
pub symbol: String,
pub name: String,
pub quantity: f64,
pub cost_basis: f64,
#[serde(
deserialize_with = "deserialize_date",
serialize_with = "serialize_date"
)]
pub date: DateTime<Utc>,
#[serde(
default,
deserialize_with = "source",
skip_serializing_if = "Option::is_none"
)]
pub source: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Estimate {
pub value: f64,
#[serde(
deserialize_with = "deserialize_date",
serialize_with = "serialize_date"
)]
pub date: DateTime<Utc>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Holding {
pub id: String,
pub name: String,
#[serde(default)]
pub estimates: Vec<Estimate>,
}
#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(untagged)]
pub enum PositionOrHolding {
Position(Position),
Holding(Holding),
}
impl<'de> Deserialize<'de> for PositionOrHolding {
fn deserialize<D: serde::Deserializer<'de>>(
deserializer: D,
) -> std::result::Result<Self, D::Error> {
let raw = Value::deserialize(deserializer)?;
if raw.get("asset").is_some() {
serde_json::from_value(raw)
.map(PositionOrHolding::Position)
.map_err(serde::de::Error::custom)
} else {
serde_json::from_value(raw)
.map(PositionOrHolding::Holding)
.map_err(serde::de::Error::custom)
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Portfolio {
pub id: String,
pub name: String,
#[serde(default)]
pub profile: Vec<PositionOrHolding>,
#[serde(
deserialize_with = "deserialize_date",
serialize_with = "serialize_date"
)]
pub created: DateTime<Utc>,
#[serde(
deserialize_with = "deserialize_date",
serialize_with = "serialize_date"
)]
pub last_modified: DateTime<Utc>,
}
#[derive(Debug, Clone, Default)]
pub struct GroupOpts {
pub group: Option<Group>,
}
fn request(
request: reqwest::RequestBuilder,
authorization: &CredentialsOrApiKey,
opts: &GroupOpts,
) -> reqwest::RequestBuilder {
let request = request.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => format!("Token {}", credentials.token),
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
match &opts.group {
Some(group) => request.header("Group", &group.id),
None => request,
}
}
fn portfolio_url(portfolio_id: &str) -> String {
format!(
"{}/magpie/portfolios/{}",
super::get_url(),
encode(portfolio_id)
)
}
pub async fn get_portfolios(
authorization: &CredentialsOrApiKey,
opts: GroupOpts,
) -> Result<Vec<Portfolio>> {
let response = request(
client().get(format!("{}/magpie/portfolios", super::get_url())),
authorization,
&opts,
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get_portfolio(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
opts: GroupOpts,
) -> Result<Portfolio> {
let response = request(
client().get(portfolio_url(portfolio_id)),
authorization,
&opts,
)
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
async fn created_id(response: reqwest::Response) -> Result<String> {
let json: Value = ok(response).await?.json().await?;
Ok(match &json["id"] {
Value::String(id) => id.clone(),
Value::Null => String::new(),
id => id.to_string(),
})
}
pub async fn create_portfolio(
authorization: &CredentialsOrApiKey,
name: &str,
opts: GroupOpts,
) -> Result<String> {
let response = request(
client().post(format!("{}/magpie/portfolios", super::get_url())),
authorization,
&opts,
)
.json(&json!({ "name": name }))
.send()
.await?;
created_id(response).await
}
pub async fn remove_portfolio(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
opts: GroupOpts,
) -> Result<()> {
let response = request(
client().delete(portfolio_url(portfolio_id)),
authorization,
&opts,
)
.send()
.await?;
ok(response).await?;
Ok(())
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PositionDraft {
pub asset: Asset,
pub symbol: String,
pub name: String,
pub quantity: f64,
pub cost_basis: f64,
#[serde(
deserialize_with = "deserialize_date",
serialize_with = "serialize_date"
)]
pub date: DateTime<Utc>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
pub async fn add_position(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
position: &PositionDraft,
opts: GroupOpts,
) -> Result<String> {
let response = request(
client().post(format!("{}/positions", portfolio_url(portfolio_id))),
authorization,
&opts,
)
.json(&json!({ "position": position }))
.send()
.await?;
created_id(response).await
}
fn serialize_optional_date<S: serde::Serializer>(
date: &Option<DateTime<Utc>>,
serializer: S,
) -> std::result::Result<S::Ok, S::Error> {
match date {
Some(date) => serialize_date(date, serializer),
None => serializer.serialize_none(),
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PartialPosition {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub asset: Option<Asset>,
#[serde(skip_serializing_if = "Option::is_none")]
pub symbol: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cost_basis: Option<f64>,
#[serde(
skip_serializing_if = "Option::is_none",
serialize_with = "serialize_optional_date"
)]
pub date: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
pub async fn update_position(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
position_id: &str,
updates: &PartialPosition,
opts: GroupOpts,
) -> Result<()> {
let response = request(
client().patch(format!(
"{}/positions/{}",
portfolio_url(portfolio_id),
encode(position_id)
)),
authorization,
&opts,
)
.json(&json!({ "updates": updates }))
.send()
.await?;
ok(response).await?;
Ok(())
}
pub async fn remove_position(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
position_id: &str,
opts: GroupOpts,
) -> Result<()> {
let response = request(
client().delete(format!(
"{}/positions/{}",
portfolio_url(portfolio_id),
encode(position_id)
)),
authorization,
&opts,
)
.send()
.await?;
ok(response).await?;
Ok(())
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HoldingDraft {
pub name: String,
pub estimates: Vec<Estimate>,
}
pub async fn add_holding(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
holding: &HoldingDraft,
opts: GroupOpts,
) -> Result<String> {
let response = request(
client().post(format!("{}/holdings", portfolio_url(portfolio_id))),
authorization,
&opts,
)
.json(&json!({ "holding": holding }))
.send()
.await?;
created_id(response).await
}
pub async fn add_estimate(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
holding_id: &str,
estimate: &Estimate,
opts: GroupOpts,
) -> Result<()> {
let response = request(
client().post(format!(
"{}/holdings/{}/estimates",
portfolio_url(portfolio_id),
encode(holding_id)
)),
authorization,
&opts,
)
.json(&json!({ "estimate": estimate }))
.send()
.await?;
ok(response).await?;
Ok(())
}
pub async fn remove_holding(
authorization: &CredentialsOrApiKey,
portfolio_id: &str,
holding_id: &str,
opts: GroupOpts,
) -> Result<()> {
let response = request(
client().delete(format!(
"{}/holdings/{}",
portfolio_url(portfolio_id),
encode(holding_id)
)),
authorization,
&opts,
)
.send()
.await?;
ok(response).await?;
Ok(())
}