use std::collections::HashMap;
use std::ops::Deref;
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};
use super::explorer::Explorer;
use super::portfolio::Asset;
use crate::authentification::CredentialsOrApiKey;
use crate::error::{Error, Result};
use crate::groups::Group;
use crate::http::{client, ok};
use crate::parrot::room::{ChatRoom, RoomHooks, connect_room};
use crate::parrot::share::ChatTarget;
use crate::shared::server::{Authorization, Hooks, Presence, Room, connect as connect_server};
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PortfolioEntry {
#[serde(default)]
pub id: String,
#[serde(flatten)]
pub entry: Map<String, Value>,
}
impl Deref for PortfolioEntry {
type Target = Map<String, Value>;
fn deref(&self) -> &Map<String, Value> {
&self.entry
}
}
fn entry_key(entry: &Value) -> String {
let text = |key: &str| entry[key].as_str().filter(|value| !value.is_empty());
if let Some(id) = text("id") {
return id.to_string();
}
match (text("asset"), text("ticker")) {
(Some(asset), Some(ticker)) => format!("{asset}:{ticker}"),
_ => String::new(),
}
}
fn field<'a>(packet: &'a Value, key: &str) -> &'a Value {
if packet[key].is_null() {
&packet["data"][key]
} else {
&packet[key]
}
}
fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
mutex.lock().unwrap_or_else(PoisonError::into_inner)
}
struct Portfolio {
portfolio_id: String,
name: String,
profile: HashMap<String, PortfolioEntry>,
}
#[derive(Clone)]
pub struct PortfolioChat {
pub room: ChatRoom,
pub me: Presence,
pub chat_id: String,
}
#[derive(Default)]
pub struct ConnectOptions {
pub group: Option<Group>,
pub hooks: Option<Arc<dyn Hooks>>,
pub server: Option<String>,
}
#[derive(Clone)]
pub struct PortfolioRoom {
room: Room,
state: Arc<Mutex<Portfolio>>,
}
impl Deref for PortfolioRoom {
type Target = Room;
fn deref(&self) -> &Room {
&self.room
}
}
impl PortfolioRoom {
fn portfolio(&self) -> MutexGuard<'_, Portfolio> {
lock(&self.state)
}
pub fn portfolio_id(&self) -> String {
self.portfolio().portfolio_id.clone()
}
pub fn name(&self) -> String {
self.portfolio().name.clone()
}
pub fn profile(&self) -> HashMap<String, PortfolioEntry> {
self.portfolio().profile.clone()
}
pub fn hydrate(&self, state: &Value) {
let mut portfolio = self.portfolio();
if let Some(id) = state["id"].as_str() {
portfolio.portfolio_id = id.to_string();
}
if let Some(name) = state["name"].as_str() {
portfolio.name = name.to_string();
}
portfolio.profile = state["profile"]
.as_array()
.into_iter()
.flatten()
.filter_map(|entry| {
let key = entry_key(entry);
let entry = serde_json::from_value(entry.clone()).ok()?;
(!key.is_empty()).then_some((key, entry))
})
.collect();
}
pub fn handle_event(&self, packet: &Value) {
let mut portfolio = self.portfolio();
match packet["event"].as_str().unwrap_or_default() {
"upsert-entry" => {
let entry = field(packet, "entry");
let key = entry_key(entry);
if !key.is_empty()
&& let Ok(entry) = serde_json::from_value(entry.clone())
{
portfolio.profile.insert(key, entry);
}
}
"remove-entry" => {
if let Some(id) = field(packet, "id").as_str().filter(|id| !id.is_empty()) {
portfolio.profile.remove(id);
}
}
"update-portfolio" => {
if let Some(name) = field(packet, "portfolio")["name"]
.as_str()
.filter(|name| !name.is_empty())
{
portfolio.name = name.to_string();
}
}
_ => {}
}
}
pub async fn get_chat(&self, hooks: Option<Arc<dyn RoomHooks>>) -> Result<PortfolioChat> {
let authorization = self.get_authorization();
let request = client()
.post(format!("{}/magpie/portfolio/chat/ensure", super::get_url()))
.header("Content-Type", "application/json")
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
let request = match self.authorization() {
Authorization::AccessCode { access_code, .. } => {
request.header("Access-Code", access_code)
}
Authorization::Server { group, .. } => {
let request = request.header("Server", self.portfolio_id());
match group {
Some(group) => request.header("Group", group),
None => request,
}
}
};
let json: Value = ok(request.send().await?).await?.json().await?;
let chat_id = json["chatId"].as_str().unwrap_or_default().to_string();
let code = json["code"].as_str().unwrap_or_default().to_string();
if chat_id.is_empty() || code.is_empty() {
return Err(Error::Message("Invalid ensure response.".to_string()));
}
let target = match self.authorization() {
Authorization::AccessCode { .. } => ChatTarget::Code { code },
Authorization::Server { .. } => ChatTarget::Reference {
reference: json["reference"]
.as_str()
.filter(|reference| !reference.is_empty())
.map(str::to_string)
.unwrap_or_else(|| format!("parrot:chat:{chat_id}")),
},
};
let (room, me) = connect_room(authorization, &target, hooks).await?;
Ok(PortfolioChat { room, me, chat_id })
}
pub async fn connect(
authorization: &CredentialsOrApiKey,
target_id: &str,
opts: ConnectOptions,
) -> Result<(PortfolioRoom, Presence)> {
PortfolioRoom::open(
Authorization::Server {
authorization: authorization.clone(),
server: opts.server.unwrap_or_else(|| target_id.to_string()),
group: opts.group.as_ref().map(|group| group.id.clone()),
},
opts.hooks,
)
.await
}
pub async fn join(
authorization: &CredentialsOrApiKey,
access_code: &str,
hooks: Option<Arc<dyn Hooks>>,
) -> Result<(PortfolioRoom, Presence)> {
PortfolioRoom::open(
Authorization::AccessCode {
authorization: authorization.clone(),
access_code: access_code.to_string(),
},
hooks,
)
.await
}
async fn open(
auth: Authorization,
hooks: Option<Arc<dyn Hooks>>,
) -> Result<(PortfolioRoom, Presence)> {
let state = Arc::new(Mutex::new(Portfolio {
portfolio_id: String::new(),
name: String::new(),
profile: HashMap::new(),
}));
let me = connect_server(
auth,
&format!("{}/magpie/portfolio", super::get_url()),
Arc::new(PortfolioHooks {
state: state.clone(),
user: hooks.unwrap_or_else(|| Arc::new(())),
}),
)
.await?;
Ok((
PortfolioRoom {
room: me.room().clone(),
state,
},
me,
))
}
}
struct PortfolioHooks {
state: Arc<Mutex<Portfolio>>,
user: Arc<dyn Hooks>,
}
impl Hooks for PortfolioHooks {
fn create_room(&self, room: &Room, state: &Value) {
lock(&self.state).portfolio_id = room.id().to_string();
self.user.create_room(room, state);
}
fn create_presence(&self, room: &Room, presence: &Presence) {
self.user.create_presence(room, presence);
}
fn remove_presence(&self, room: &Room, presence: &Presence) {
self.user.remove_presence(room, presence);
}
fn on_connection(&self, room: &Room, state: &Value) {
PortfolioRoom {
room: room.clone(),
state: self.state.clone(),
}
.hydrate(state);
self.user.on_connection(room, state);
}
fn on_event(&self, room: &Room, packet: &Value) -> bool {
PortfolioRoom {
room: room.clone(),
state: self.state.clone(),
}
.handle_event(packet);
self.user.on_event(room, packet);
true
}
fn on_presence(&self, room: &Room) {
self.user.on_presence(room);
}
fn on_closed(&self, room: &Room, reason: Option<&str>) {
self.user.on_closed(room, reason);
}
}
fn explorer_key(asset: Option<&str>, ticker: Option<&str>) -> String {
match (
asset.filter(|asset| !asset.is_empty()),
ticker.filter(|ticker| !ticker.is_empty()),
) {
(Some(asset), Some(ticker)) => format!("{asset}:{ticker}"),
_ => String::new(),
}
}
struct Explorers {
host: String,
entries: HashMap<String, Explorer>,
}
#[derive(Default)]
pub struct ExplorerConnectOptions {
pub hooks: Option<Arc<dyn Hooks>>,
pub server: Option<String>,
}
#[derive(Clone)]
pub struct ExplorerRoom {
room: Room,
state: Arc<Mutex<Explorers>>,
}
impl Deref for ExplorerRoom {
type Target = Room;
fn deref(&self) -> &Room {
&self.room
}
}
impl ExplorerRoom {
fn explorers(&self) -> MutexGuard<'_, Explorers> {
lock(&self.state)
}
pub fn host(&self) -> String {
self.explorers().host.clone()
}
pub fn entries(&self) -> HashMap<String, Explorer> {
self.explorers().entries.clone()
}
pub fn hydrate(&self, state: &Value) {
let mut explorers = self.explorers();
if let Some(host) = state["host"].as_str() {
explorers.host = host.to_string();
}
explorers.entries = state["entries"]
.as_array()
.into_iter()
.flatten()
.filter_map(|entry| {
let key = explorer_key(entry["asset"].as_str(), entry["ticker"].as_str());
let entry = serde_json::from_value(entry.clone()).ok()?;
(!key.is_empty()).then_some((key, entry))
})
.collect();
}
pub fn handle_event(&self, packet: &Value) {
let mut explorers = self.explorers();
match packet["event"].as_str().unwrap_or_default() {
"upsert-entry" => {
let entry = field(packet, "entry");
let key = explorer_key(entry["asset"].as_str(), entry["ticker"].as_str());
if !key.is_empty()
&& let Ok(entry) = serde_json::from_value(entry.clone())
{
explorers.entries.insert(key, entry);
}
}
"remove-entry" => {
let key = explorer_key(
field(packet, "asset").as_str(),
field(packet, "ticker").as_str(),
);
if !key.is_empty() {
explorers.entries.remove(&key);
}
}
_ => {}
}
}
pub fn set_ticker(&self, asset: Asset, ticker: &str) {
self.post(&json!({ "event": "set-ticker", "asset": asset, "ticker": ticker }));
}
pub fn commit_drawing(&self, explorer: &Explorer) {
self.post(&json!({ "event": "draw-commit", "explorer": explorer }));
}
pub fn clear_drawings(&self, asset: Asset, ticker: &str) {
self.post(&json!({ "event": "draw-clear", "asset": asset, "ticker": ticker }));
}
pub async fn connect(
authorization: &CredentialsOrApiKey,
opts: ExplorerConnectOptions,
) -> Result<(ExplorerRoom, Presence)> {
ExplorerRoom::open(
Authorization::Server {
authorization: authorization.clone(),
server: opts.server.unwrap_or_else(|| "me".to_string()),
group: None,
},
opts.hooks,
)
.await
}
pub async fn join(
authorization: &CredentialsOrApiKey,
access_code: &str,
hooks: Option<Arc<dyn Hooks>>,
) -> Result<(ExplorerRoom, Presence)> {
ExplorerRoom::open(
Authorization::AccessCode {
authorization: authorization.clone(),
access_code: access_code.to_string(),
},
hooks,
)
.await
}
async fn open(
auth: Authorization,
hooks: Option<Arc<dyn Hooks>>,
) -> Result<(ExplorerRoom, Presence)> {
let state = Arc::new(Mutex::new(Explorers {
host: String::new(),
entries: HashMap::new(),
}));
let me = connect_server(
auth,
&format!("{}/magpie/explorer", super::get_url()),
Arc::new(ExplorerHooks {
state: state.clone(),
user: hooks.unwrap_or_else(|| Arc::new(())),
}),
)
.await?;
Ok((
ExplorerRoom {
room: me.room().clone(),
state,
},
me,
))
}
}
struct ExplorerHooks {
state: Arc<Mutex<Explorers>>,
user: Arc<dyn Hooks>,
}
impl Hooks for ExplorerHooks {
fn create_room(&self, room: &Room, state: &Value) {
lock(&self.state).host = room.id().to_string();
self.user.create_room(room, state);
}
fn create_presence(&self, room: &Room, presence: &Presence) {
self.user.create_presence(room, presence);
}
fn remove_presence(&self, room: &Room, presence: &Presence) {
self.user.remove_presence(room, presence);
}
fn on_connection(&self, room: &Room, state: &Value) {
ExplorerRoom {
room: room.clone(),
state: self.state.clone(),
}
.hydrate(state);
self.user.on_connection(room, state);
}
fn on_event(&self, room: &Room, packet: &Value) -> bool {
ExplorerRoom {
room: room.clone(),
state: self.state.clone(),
}
.handle_event(packet);
self.user.on_event(room, packet);
true
}
fn on_presence(&self, room: &Room) {
self.user.on_presence(room);
}
fn on_closed(&self, room: &Room, reason: Option<&str>) {
self.user.on_closed(room, reason);
}
}
#[cfg(test)]
mod tests {
use serde_json::json;
use tokio::sync::mpsc;
use super::*;
use crate::authentification::ApiKey;
fn room() -> Room {
let (ws, _outbox) = mpsc::unbounded_channel();
Room::new(
"http://localhost/magpie".to_string(),
ws,
Authorization::Server {
authorization: CredentialsOrApiKey::ApiKey(ApiKey::default()),
server: "me".to_string(),
group: None,
},
"p1".to_string(),
)
}
#[test]
fn portfolio_and_explorer_rooms_follow_their_events() {
let portfolio = PortfolioRoom {
room: room(),
state: Arc::new(Mutex::new(Portfolio {
portfolio_id: "p1".to_string(),
name: String::new(),
profile: HashMap::new(),
})),
};
portfolio.hydrate(&json!({
"name": "Retirement",
"profile": [{ "id": "a", "asset": "EQUITY", "symbol": "AAPL" }, { "asset": "CRYPTO", "ticker": "BTC" }, {}]
}));
assert_eq!(portfolio.profile().len(), 2);
assert_eq!(portfolio.profile()["a"]["symbol"], "AAPL");
assert!(portfolio.profile().contains_key("CRYPTO:BTC"));
portfolio.handle_event(&json!({ "event": "remove-entry", "data": { "id": "a" } }));
portfolio
.handle_event(&json!({ "event": "update-portfolio", "portfolio": { "name": "Fun" } }));
assert_eq!(portfolio.profile().len(), 1);
assert_eq!(portfolio.name(), "Fun");
let explorer = ExplorerRoom {
room: room(),
state: Arc::new(Mutex::new(Explorers {
host: String::new(),
entries: HashMap::new(),
})),
};
explorer.hydrate(&json!({
"host": "credentials:1",
"entries": [{ "ticker": "AAPL", "asset": "EQUITY", "trends": [[1, 2, 3, 4]], "horizontals": [190.5], "notifications": [] }]
}));
assert_eq!(
explorer.entries()["EQUITY:AAPL"].trends[0],
[1.0, 2.0, 3.0, 4.0]
);
explorer
.handle_event(&json!({ "event": "remove-entry", "asset": "EQUITY", "ticker": "AAPL" }));
assert!(explorer.entries().is_empty());
}
}