Skip to main content

fauna_api/magpie/
room.rs

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/// `Record<string, any> & { id }` in the TypeScript SDK: a portfolio entry as
19/// the room sends it, by id.
20#[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/// `{ room, self, chatId }` in the TypeScript SDK, with `self` as `me`.
65#[derive(Clone)]
66pub struct PortfolioChat {
67    pub room: ChatRoom,
68    pub me: Presence,
69    pub chat_id: String,
70}
71
72/// The `opts` argument of `PortfolioRoom::connect`. `server` names the room when
73/// it isn't the portfolio's id.
74#[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/// The `opts` argument of `ExplorerRoom::connect`. `server` defaults to `me`,
328/// the caller's own explorer.
329#[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        // "me" is resolved on the edge to the caller's credentials principal.
420        // Client Credentials has no server id.
421        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}