amagi 0.1.1

Rust SDK, CLI, and Web API service skeleton for multi-platform social web adapters.
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use serde_json::Value;

use crate::error::AppError;

use super::{
    super::types::{KuaishouEmojiList, KuaishouEmojiListData, KuaishouLiveRoomInfo},
    KuaishouFetcher,
    graphql::EmojiListRequest,
    live::{KuaishouLiveRoomSources, build_kuaishou_live_room_info},
    requests,
};

impl KuaishouFetcher {
    /// Fetch the aggregated live-room info for a Kuaishou principal id.
    ///
    /// # Errors
    ///
    /// Returns an error when the primary live-detail request fails or the
    /// upstream responses cannot be decoded.
    #[doc(alias = "fetchLiveRoomInfo")]
    pub async fn fetch_live_room_info(
        &self,
        principal_id: &str,
    ) -> Result<KuaishouLiveRoomInfo, AppError> {
        let referer_path = format!("u/{principal_id}");
        let base_url = self.live_base_url.as_ref();
        let live_detail_request = requests::live_detail(base_url, principal_id)?;
        let user_info_request = requests::user_info_by_id(base_url, principal_id)?;
        let sensitive_request = requests::user_sensitive_info(base_url, principal_id)?;
        let emoji_request = EmojiListRequest::default();

        let (live_detail_payload, user_info_payload, sensitive_payload, emoji_payload) = tokio::join!(
            self.send_live_api_request(&live_detail_request, &referer_path, true),
            self.send_live_api_request(&user_info_request, &referer_path, true),
            self.send_live_api_request(&sensitive_request, &referer_path, true),
            self.send_graphql_data(&emoji_request),
        );

        let live_detail_payload = live_detail_payload?;
        let user_info_payload = user_info_payload.ok();
        let sensitive_payload = sensitive_payload.ok();
        let emoji_payload = emoji_payload.ok().and_then(|data| {
            serde_json::from_value::<KuaishouEmojiListData>(data.clone())
                .ok()
                .map(|parsed| KuaishouEmojiList {
                    data: parsed,
                    upstream_payload: data,
                })
        });

        let live_stream_id = live_detail_payload
            .get("data")
            .and_then(|value| value.get("liveStream"))
            .and_then(|value| value.get("id"))
            .and_then(Value::as_str)
            .map(str::to_owned)
            .or_else(|| {
                live_detail_payload
                    .get("data")
                    .and_then(|value| value.get("config"))
                    .and_then(|value| value.get("liveStreamId"))
                    .and_then(Value::as_str)
                    .map(str::to_owned)
            });
        let current_game_id = live_detail_payload
            .get("data")
            .and_then(|value| value.get("gameInfo"))
            .and_then(|value| value.get("id").or_else(|| value.get("gameId")))
            .and_then(|value| match value {
                Value::String(value) => Some(value.clone()),
                Value::Number(value) => Some(value.to_string()),
                _ => None,
            });
        let detail_websocket_urls = live_detail_payload
            .get("data")
            .and_then(|value| value.get("websocketInfo"))
            .and_then(|value| value.get("websocketUrls"))
            .and_then(Value::as_array)
            .map(Vec::len)
            .unwrap_or_default();
        let detail_websocket_token = live_detail_payload
            .get("data")
            .and_then(|value| value.get("websocketInfo"))
            .and_then(|value| value.get("token"))
            .and_then(Value::as_str)
            .unwrap_or_default()
            .to_owned();
        let detail_recommend_count = live_detail_payload
            .get("data")
            .and_then(|value| value.get("recommendList"))
            .and_then(Value::as_array)
            .map(Vec::len)
            .unwrap_or_default();

        let gift_request = live_stream_id
            .as_deref()
            .map(|id| requests::live_gift_list(base_url, id))
            .transpose()?;
        let websocket_request = (detail_websocket_urls == 0 || detail_websocket_token.is_empty())
            .then(|| {
                live_stream_id
                    .as_deref()
                    .map(|id| requests::live_websocket_info(base_url, id))
                    .transpose()
            })
            .transpose()?
            .flatten();
        let reco_request = (detail_recommend_count == 0)
            .then(|| requests::live_reco(base_url, current_game_id.as_deref()))
            .transpose()?;

        let (gift_payload, websocket_payload, reco_payload) = tokio::join!(
            async {
                match gift_request.as_ref() {
                    Some(request) => self
                        .send_live_api_request(request, &referer_path, true)
                        .await
                        .ok(),
                    None => None,
                }
            },
            async {
                match websocket_request.as_ref() {
                    Some(request) => self
                        .send_live_api_request(request, &referer_path, true)
                        .await
                        .ok(),
                    None => None,
                }
            },
            async {
                match reco_request.as_ref() {
                    Some(request) => self
                        .send_live_api_request(request, &referer_path, true)
                        .await
                        .ok(),
                    None => None,
                }
            },
        );

        Ok(build_kuaishou_live_room_info(
            principal_id,
            KuaishouLiveRoomSources {
                user_info_payload: user_info_payload.as_ref(),
                sensitive_payload: sensitive_payload.as_ref(),
                live_detail_payload: &live_detail_payload,
                emoji_payload: emoji_payload.as_ref(),
                gift_payload: gift_payload.as_ref(),
                websocket_payload: websocket_payload.as_ref(),
                reco_payload: reco_payload.as_ref(),
            },
        ))
    }
}