dlsite 0.2.0

DLsite client
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

pub mod options;

use scraper::{Html, Selector};

use crate::{
    search::{parse_search_html, SearchResult},
    utils::ToParseError,
    DlsiteClient, Result,
};

use self::options::CircleQueryOptions;

impl DlsiteClient {
    pub async fn get_circle(
        &self,
        circle_id: &str,
        options: &CircleQueryOptions,
    ) -> Result<SearchResult> {
        let query_path = options.to_path(circle_id);
        let html = self.get(&query_path).await?;
        let html = Html::parse_fragment(&html);
        let products_html = html
            .select(&Selector::parse("#search_result_list").unwrap())
            .next()
            .to_parse_error("Product list not found")?;

        let count: i32 = html
            .select(&Selector::parse(".page_total > strong").unwrap())
            .next()
            .to_parse_error("No total item count found")?
            .text()
            .next()
            .to_parse_error("No total item count found 2")?
            .parse()
            .to_parse_error("Failed to parse total item count")?;

        let products = parse_search_html(&products_html.html())?;

        Ok(SearchResult {
            products,
            count,
            query_path,
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::DlsiteClient;

    #[tokio::test]
    async fn get_circle_1() {
        let client = DlsiteClient::default();
        let res = client
            .get_circle(
                "RG24350",
                &super::CircleQueryOptions {
                    ..Default::default()
                },
            )
            .await
            .expect("Failed to search");

        assert_eq!(50, res.products.len());

        res.products.iter().for_each(|r| {
            dbg!(&r);
        });

        let res = client
            .get_circle(
                "RG24350",
                &super::CircleQueryOptions {
                    page: Some(2),
                    ..Default::default()
                },
            )
            .await
            .expect("Failed to search");

        assert!(!res.products.is_empty());
    }
}