1use std::collections::HashMap;
2use std::ops::Deref;
3use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
4
5use serde::{Deserialize, Serialize};
6use serde_json::{Map, Value, json};
7
8use super::explorer::Explorer;
9use super::portfolio::Asset;
10use crate::authentification::CredentialsOrApiKey;
11use crate::error::{Error, Result};
12use crate::groups::Group;
13use crate::http::{client, ok};
14use crate::parrot::room::{ChatRoom, RoomHooks, connect_room};
15use crate::parrot::share::ChatTarget;
16use crate::shared::server::{Authorization, Hooks, Presence, Room, connect as connect_server};
17
18#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
21pub struct PortfolioEntry {
22 #[serde(default)]
23 pub id: String,
24 #[serde(flatten)]
25 pub entry: Map<String, Value>,
26}
27
28impl Deref for PortfolioEntry {
29 type Target = Map<String, Value>;
30 fn deref(&self) -> &Map<String, Value> {
31 &self.entry
32 }
33}
34
35fn entry_key(entry: &Value) -> String {
36 let text = |key: &str| entry[key].as_str().filter(|value| !value.is_empty());
37 if let Some(id) = text("id") {
38 return id.to_string();
39 }
40 match (text("asset"), text("ticker")) {
41 (Some(asset), Some(ticker)) => format!("{asset}:{ticker}"),
42 _ => String::new(),
43 }
44}
45
46fn field<'a>(packet: &'a Value, key: &str) -> &'a Value {
47 if packet[key].is_null() {
48 &packet["data"][key]
49 } else {
50 &packet[key]
51 }
52}
53
54fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
55 mutex.lock().unwrap_or_else(PoisonError::into_inner)
56}
57
58struct Portfolio {
59 portfolio_id: String,
60 name: String,
61 profile: HashMap<String, PortfolioEntry>,
62}
63
64#[derive(Clone)]
66pub struct PortfolioChat {
67 pub room: ChatRoom,
68 pub me: Presence,
69 pub chat_id: String,
70}
71
72#[derive(Default)]
75pub struct ConnectOptions {
76 pub group: Option<Group>,
77 pub hooks: Option<Arc<dyn Hooks>>,
78 pub server: Option<String>,
79}
80
81#[derive(Clone)]
82pub struct PortfolioRoom {
83 room: Room,
84 state: Arc<Mutex<Portfolio>>,
85}
86
87impl Deref for PortfolioRoom {
88 type Target = Room;
89 fn deref(&self) -> &Room {
90 &self.room
91 }
92}
93
94impl PortfolioRoom {
95 fn portfolio(&self) -> MutexGuard<'_, Portfolio> {
96 lock(&self.state)
97 }
98
99 pub fn portfolio_id(&self) -> String {
100 self.portfolio().portfolio_id.clone()
101 }
102
103 pub fn name(&self) -> String {
104 self.portfolio().name.clone()
105 }
106
107 pub fn profile(&self) -> HashMap<String, PortfolioEntry> {
108 self.portfolio().profile.clone()
109 }
110
111 pub fn hydrate(&self, state: &Value) {
112 let mut portfolio = self.portfolio();
113 if let Some(id) = state["id"].as_str() {
114 portfolio.portfolio_id = id.to_string();
115 }
116 if let Some(name) = state["name"].as_str() {
117 portfolio.name = name.to_string();
118 }
119 portfolio.profile = state["profile"]
120 .as_array()
121 .into_iter()
122 .flatten()
123 .filter_map(|entry| {
124 let key = entry_key(entry);
125 let entry = serde_json::from_value(entry.clone()).ok()?;
126 (!key.is_empty()).then_some((key, entry))
127 })
128 .collect();
129 }
130
131 pub fn handle_event(&self, packet: &Value) {
132 let mut portfolio = self.portfolio();
133 match packet["event"].as_str().unwrap_or_default() {
134 "upsert-entry" => {
135 let entry = field(packet, "entry");
136 let key = entry_key(entry);
137 if !key.is_empty()
138 && let Ok(entry) = serde_json::from_value(entry.clone())
139 {
140 portfolio.profile.insert(key, entry);
141 }
142 }
143 "remove-entry" => {
144 if let Some(id) = field(packet, "id").as_str().filter(|id| !id.is_empty()) {
145 portfolio.profile.remove(id);
146 }
147 }
148 "update-portfolio" => {
149 if let Some(name) = field(packet, "portfolio")["name"]
150 .as_str()
151 .filter(|name| !name.is_empty())
152 {
153 portfolio.name = name.to_string();
154 }
155 }
156 _ => {}
157 }
158 }
159
160 pub async fn get_chat(&self, hooks: Option<Arc<dyn RoomHooks>>) -> Result<PortfolioChat> {
161 let authorization = self.get_authorization();
162 let request = client()
163 .post(format!("{}/magpie/portfolio/chat/ensure", super::get_url()))
164 .header("Content-Type", "application/json")
165 .header(
166 "Authorization",
167 match authorization {
168 CredentialsOrApiKey::Credentials(credentials) => {
169 format!("Token {}", credentials.token)
170 }
171 CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
172 },
173 );
174 let request = match self.authorization() {
175 Authorization::AccessCode { access_code, .. } => {
176 request.header("Access-Code", access_code)
177 }
178 Authorization::Server { group, .. } => {
179 let request = request.header("Server", self.portfolio_id());
180 match group {
181 Some(group) => request.header("Group", group),
182 None => request,
183 }
184 }
185 };
186 let json: Value = ok(request.send().await?).await?.json().await?;
187 let chat_id = json["chatId"].as_str().unwrap_or_default().to_string();
188 let code = json["code"].as_str().unwrap_or_default().to_string();
189 if chat_id.is_empty() || code.is_empty() {
190 return Err(Error::Message("Invalid ensure response.".to_string()));
191 }
192 let target = match self.authorization() {
193 Authorization::AccessCode { .. } => ChatTarget::Code { code },
194 Authorization::Server { .. } => ChatTarget::Reference {
195 reference: json["reference"]
196 .as_str()
197 .filter(|reference| !reference.is_empty())
198 .map(str::to_string)
199 .unwrap_or_else(|| format!("parrot:chat:{chat_id}")),
200 },
201 };
202 let (room, me) = connect_room(authorization, &target, hooks).await?;
203 Ok(PortfolioChat { room, me, chat_id })
204 }
205
206 pub async fn connect(
207 authorization: &CredentialsOrApiKey,
208 target_id: &str,
209 opts: ConnectOptions,
210 ) -> Result<(PortfolioRoom, Presence)> {
211 PortfolioRoom::open(
212 Authorization::Server {
213 authorization: authorization.clone(),
214 server: opts.server.unwrap_or_else(|| target_id.to_string()),
215 group: opts.group.as_ref().map(|group| group.id.clone()),
216 },
217 opts.hooks,
218 )
219 .await
220 }
221
222 pub async fn join(
223 authorization: &CredentialsOrApiKey,
224 access_code: &str,
225 hooks: Option<Arc<dyn Hooks>>,
226 ) -> Result<(PortfolioRoom, Presence)> {
227 PortfolioRoom::open(
228 Authorization::AccessCode {
229 authorization: authorization.clone(),
230 access_code: access_code.to_string(),
231 },
232 hooks,
233 )
234 .await
235 }
236
237 async fn open(
238 auth: Authorization,
239 hooks: Option<Arc<dyn Hooks>>,
240 ) -> Result<(PortfolioRoom, Presence)> {
241 let state = Arc::new(Mutex::new(Portfolio {
242 portfolio_id: String::new(),
243 name: String::new(),
244 profile: HashMap::new(),
245 }));
246 let me = connect_server(
247 auth,
248 &format!("{}/magpie/portfolio", super::get_url()),
249 Arc::new(PortfolioHooks {
250 state: state.clone(),
251 user: hooks.unwrap_or_else(|| Arc::new(())),
252 }),
253 )
254 .await?;
255 Ok((
256 PortfolioRoom {
257 room: me.room().clone(),
258 state,
259 },
260 me,
261 ))
262 }
263}
264
265struct PortfolioHooks {
266 state: Arc<Mutex<Portfolio>>,
267 user: Arc<dyn Hooks>,
268}
269
270impl Hooks for PortfolioHooks {
271 fn create_room(&self, room: &Room, state: &Value) {
272 lock(&self.state).portfolio_id = room.id().to_string();
273 self.user.create_room(room, state);
274 }
275
276 fn create_presence(&self, room: &Room, presence: &Presence) {
277 self.user.create_presence(room, presence);
278 }
279
280 fn remove_presence(&self, room: &Room, presence: &Presence) {
281 self.user.remove_presence(room, presence);
282 }
283
284 fn on_connection(&self, room: &Room, state: &Value) {
285 PortfolioRoom {
286 room: room.clone(),
287 state: self.state.clone(),
288 }
289 .hydrate(state);
290 self.user.on_connection(room, state);
291 }
292
293 fn on_event(&self, room: &Room, packet: &Value) -> bool {
294 PortfolioRoom {
295 room: room.clone(),
296 state: self.state.clone(),
297 }
298 .handle_event(packet);
299 self.user.on_event(room, packet);
300 true
301 }
302
303 fn on_presence(&self, room: &Room) {
304 self.user.on_presence(room);
305 }
306
307 fn on_closed(&self, room: &Room, reason: Option<&str>) {
308 self.user.on_closed(room, reason);
309 }
310}
311
312fn explorer_key(asset: Option<&str>, ticker: Option<&str>) -> String {
313 match (
314 asset.filter(|asset| !asset.is_empty()),
315 ticker.filter(|ticker| !ticker.is_empty()),
316 ) {
317 (Some(asset), Some(ticker)) => format!("{asset}:{ticker}"),
318 _ => String::new(),
319 }
320}
321
322struct Explorers {
323 host: String,
324 entries: HashMap<String, Explorer>,
325}
326
327#[derive(Default)]
330pub struct ExplorerConnectOptions {
331 pub hooks: Option<Arc<dyn Hooks>>,
332 pub server: Option<String>,
333}
334
335#[derive(Clone)]
336pub struct ExplorerRoom {
337 room: Room,
338 state: Arc<Mutex<Explorers>>,
339}
340
341impl Deref for ExplorerRoom {
342 type Target = Room;
343 fn deref(&self) -> &Room {
344 &self.room
345 }
346}
347
348impl ExplorerRoom {
349 fn explorers(&self) -> MutexGuard<'_, Explorers> {
350 lock(&self.state)
351 }
352
353 pub fn host(&self) -> String {
354 self.explorers().host.clone()
355 }
356
357 pub fn entries(&self) -> HashMap<String, Explorer> {
358 self.explorers().entries.clone()
359 }
360
361 pub fn hydrate(&self, state: &Value) {
362 let mut explorers = self.explorers();
363 if let Some(host) = state["host"].as_str() {
364 explorers.host = host.to_string();
365 }
366 explorers.entries = state["entries"]
367 .as_array()
368 .into_iter()
369 .flatten()
370 .filter_map(|entry| {
371 let key = explorer_key(entry["asset"].as_str(), entry["ticker"].as_str());
372 let entry = serde_json::from_value(entry.clone()).ok()?;
373 (!key.is_empty()).then_some((key, entry))
374 })
375 .collect();
376 }
377
378 pub fn handle_event(&self, packet: &Value) {
379 let mut explorers = self.explorers();
380 match packet["event"].as_str().unwrap_or_default() {
381 "upsert-entry" => {
382 let entry = field(packet, "entry");
383 let key = explorer_key(entry["asset"].as_str(), entry["ticker"].as_str());
384 if !key.is_empty()
385 && let Ok(entry) = serde_json::from_value(entry.clone())
386 {
387 explorers.entries.insert(key, entry);
388 }
389 }
390 "remove-entry" => {
391 let key = explorer_key(
392 field(packet, "asset").as_str(),
393 field(packet, "ticker").as_str(),
394 );
395 if !key.is_empty() {
396 explorers.entries.remove(&key);
397 }
398 }
399 _ => {}
400 }
401 }
402
403 pub fn set_ticker(&self, asset: Asset, ticker: &str) {
404 self.post(&json!({ "event": "set-ticker", "asset": asset, "ticker": ticker }));
405 }
406
407 pub fn commit_drawing(&self, explorer: &Explorer) {
408 self.post(&json!({ "event": "draw-commit", "explorer": explorer }));
409 }
410
411 pub fn clear_drawings(&self, asset: Asset, ticker: &str) {
412 self.post(&json!({ "event": "draw-clear", "asset": asset, "ticker": ticker }));
413 }
414
415 pub async fn connect(
416 authorization: &CredentialsOrApiKey,
417 opts: ExplorerConnectOptions,
418 ) -> Result<(ExplorerRoom, Presence)> {
419 ExplorerRoom::open(
422 Authorization::Server {
423 authorization: authorization.clone(),
424 server: opts.server.unwrap_or_else(|| "me".to_string()),
425 group: None,
426 },
427 opts.hooks,
428 )
429 .await
430 }
431
432 pub async fn join(
433 authorization: &CredentialsOrApiKey,
434 access_code: &str,
435 hooks: Option<Arc<dyn Hooks>>,
436 ) -> Result<(ExplorerRoom, Presence)> {
437 ExplorerRoom::open(
438 Authorization::AccessCode {
439 authorization: authorization.clone(),
440 access_code: access_code.to_string(),
441 },
442 hooks,
443 )
444 .await
445 }
446
447 async fn open(
448 auth: Authorization,
449 hooks: Option<Arc<dyn Hooks>>,
450 ) -> Result<(ExplorerRoom, Presence)> {
451 let state = Arc::new(Mutex::new(Explorers {
452 host: String::new(),
453 entries: HashMap::new(),
454 }));
455 let me = connect_server(
456 auth,
457 &format!("{}/magpie/explorer", super::get_url()),
458 Arc::new(ExplorerHooks {
459 state: state.clone(),
460 user: hooks.unwrap_or_else(|| Arc::new(())),
461 }),
462 )
463 .await?;
464 Ok((
465 ExplorerRoom {
466 room: me.room().clone(),
467 state,
468 },
469 me,
470 ))
471 }
472}
473
474struct ExplorerHooks {
475 state: Arc<Mutex<Explorers>>,
476 user: Arc<dyn Hooks>,
477}
478
479impl Hooks for ExplorerHooks {
480 fn create_room(&self, room: &Room, state: &Value) {
481 lock(&self.state).host = room.id().to_string();
482 self.user.create_room(room, state);
483 }
484
485 fn create_presence(&self, room: &Room, presence: &Presence) {
486 self.user.create_presence(room, presence);
487 }
488
489 fn remove_presence(&self, room: &Room, presence: &Presence) {
490 self.user.remove_presence(room, presence);
491 }
492
493 fn on_connection(&self, room: &Room, state: &Value) {
494 ExplorerRoom {
495 room: room.clone(),
496 state: self.state.clone(),
497 }
498 .hydrate(state);
499 self.user.on_connection(room, state);
500 }
501
502 fn on_event(&self, room: &Room, packet: &Value) -> bool {
503 ExplorerRoom {
504 room: room.clone(),
505 state: self.state.clone(),
506 }
507 .handle_event(packet);
508 self.user.on_event(room, packet);
509 true
510 }
511
512 fn on_presence(&self, room: &Room) {
513 self.user.on_presence(room);
514 }
515
516 fn on_closed(&self, room: &Room, reason: Option<&str>) {
517 self.user.on_closed(room, reason);
518 }
519}
520
521#[cfg(test)]
522mod tests {
523 use serde_json::json;
524 use tokio::sync::mpsc;
525
526 use super::*;
527 use crate::authentification::ApiKey;
528
529 fn room() -> Room {
530 let (ws, _outbox) = mpsc::unbounded_channel();
531 Room::new(
532 "http://localhost/magpie".to_string(),
533 ws,
534 Authorization::Server {
535 authorization: CredentialsOrApiKey::ApiKey(ApiKey::default()),
536 server: "me".to_string(),
537 group: None,
538 },
539 "p1".to_string(),
540 )
541 }
542
543 #[test]
544 fn portfolio_and_explorer_rooms_follow_their_events() {
545 let portfolio = PortfolioRoom {
546 room: room(),
547 state: Arc::new(Mutex::new(Portfolio {
548 portfolio_id: "p1".to_string(),
549 name: String::new(),
550 profile: HashMap::new(),
551 })),
552 };
553 portfolio.hydrate(&json!({
554 "name": "Retirement",
555 "profile": [{ "id": "a", "asset": "EQUITY", "symbol": "AAPL" }, { "asset": "CRYPTO", "ticker": "BTC" }, {}]
556 }));
557 assert_eq!(portfolio.profile().len(), 2);
558 assert_eq!(portfolio.profile()["a"]["symbol"], "AAPL");
559 assert!(portfolio.profile().contains_key("CRYPTO:BTC"));
560 portfolio.handle_event(&json!({ "event": "remove-entry", "data": { "id": "a" } }));
561 portfolio
562 .handle_event(&json!({ "event": "update-portfolio", "portfolio": { "name": "Fun" } }));
563 assert_eq!(portfolio.profile().len(), 1);
564 assert_eq!(portfolio.name(), "Fun");
565
566 let explorer = ExplorerRoom {
567 room: room(),
568 state: Arc::new(Mutex::new(Explorers {
569 host: String::new(),
570 entries: HashMap::new(),
571 })),
572 };
573 explorer.hydrate(&json!({
574 "host": "credentials:1",
575 "entries": [{ "ticker": "AAPL", "asset": "EQUITY", "trends": [[1, 2, 3, 4]], "horizontals": [190.5], "notifications": [] }]
576 }));
577 assert_eq!(
578 explorer.entries()["EQUITY:AAPL"].trends[0],
579 [1.0, 2.0, 3.0, 4.0]
580 );
581 explorer
582 .handle_event(&json!({ "event": "remove-entry", "asset": "EQUITY", "ticker": "AAPL" }));
583 assert!(explorer.entries().is_empty());
584 }
585}