chzzk 0.3.2

Unofficial SDK for the Korean video streaming platform Chzzk
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

use reqwest::RequestBuilder;

use crate::{
    debug_println,
    error::{chain_error, Error},
    ChzzkClient,
};

#[derive(Clone)]
pub(super) struct Nid {
    pub aut: String,
    pub ses: String,
}

pub(crate) struct ChzzkRequestBuilder {
    url: String,
}

impl ChzzkRequestBuilder {
    pub fn new(url: String) -> Self {
        Self {
            url,
        }
    }

    pub fn get(self, client: &ChzzkClient, param: Vec<(String, String)>) -> ChzzkRequestWrapper {
        let url = self.url + "?" + &param.iter().map(|(k, v)| format!("{}={}", k, v)).collect::<Vec<String>>().join("&");
        debug_println!("request to: {}.", url);
        let request = client.client.get(url);
        ChzzkRequestWrapper {
            request,
            nid: client.nid.clone(),
        }
    }

    pub fn post(self, client: &ChzzkClient, body: Option<String>) -> ChzzkRequestWrapper {
        debug_println!("request to: {}.", self.url);

        let request = client
            .client
            .post(self.url)
            .header("Content-Type", "application/json")
            .body(body.unwrap_or_default());
        
        ChzzkRequestWrapper {
            request,
            nid: client.nid.clone(),
        }
    }
}

pub(super) struct ChzzkRequestWrapper{
    request: RequestBuilder,
    nid: Option<Nid>
}

impl ChzzkRequestWrapper {
    pub async fn send<T: serde::de::DeserializeOwned>(mut self) -> Result<T, Error> {
        if let Some(nid) = self.nid {
            self.request = self.request.header("Cookie", format!("NID_AUT={};NID_SES={}", nid.aut, nid.ses));
        }
        
    let response = self.request
    .send()
    .await
    .map_err(chain_error("do_request: failed to get response"))?;

    let text = response
    .text()
    .await
    .map_err(chain_error("do_request: response is not a text"))?;

    let json = serde_json::from_str::<T>(&text)
    // let json = json::parse(text.as_str())
        .map_err(chain_error(
            format!("do_request: response is not a json. {}", text).as_str(),
        ))?;

        Ok(json)
    }
}