snoo 0.0.4

Reddit 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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use crate::reddit::Reddit;

use crate::items::{post::Post, subreddit::Subreddit, user::RedditUser, AbstractedApi};
use crate::models::{RedditResponseGeneric, SearchInfo};

use crate::endpoints::SearchSort;

use crate::endpoints::Endpoint;

use std::io;
use std::rc::Rc;

pub type PostSearch<'r, 's> = RedditSearch<'r, 's, Post<'r>>;
pub type SubredditSearch<'r, 's> = RedditSearch<'r, 's, Subreddit<'r>>;
pub type UserSearch<'r, 's> = RedditSearch<'r, 's, RedditUser<'r>>;

struct SearchParams<'r, 's> {
    reddit: &'r Reddit,
    query: &'s str,
    sort: SearchSort,
    endpoint: Endpoint,
}

pub struct RedditSearch<'r, 's, T: AbstractedApi<'r>> {
    params: Rc<SearchParams<'r, 's>>,
    results: Vec<T::AbstractedType>,
    before: Option<String>,
    after: Option<String>,
}

impl<'r, 's, T: AbstractedApi<'r>> RedditSearch<'r, 's, T> {
    pub(crate) async fn new_search(
        parent: &'r Reddit,
        search_ep: Endpoint,
        query: &'s str,
        sort: SearchSort,
    ) -> io::Result<RedditSearch<'r, 's, T>> {
        let params = Rc::from(SearchParams {
            reddit: parent,
            query: query,
            sort: sort,
            endpoint: search_ep,
        });

        Self::search(params, None, None).await
    }

    async fn search(
        params: Rc<SearchParams<'r, 's>>,
        before: Option<&str>,
        after: Option<&str>,
    ) -> io::Result<RedditSearch<'r, 's, T>> {
        let ep = params
            .endpoint
            .clone()
            .filter(Some(params.query), params.sort, before, after);

        let search = params
            .reddit
            .app
            .create_request::<RedditResponseGeneric<SearchInfo<T::ApiType>>>(ep.to_url())
            .await?
            .data;

        let results = {
            let result_info = search.results.inner_children();
            T::list_of(params.reddit, &result_info)
        };

        Ok(RedditSearch::<'r, 's> {
            params: params,
            results: results,
            before: search.before,
            after: search.after,
        })
    }

    /// Current search results
    pub fn results(&self) -> &Vec<T::AbstractedType> {
        &self.results
    }

    /// Next page of results
    pub async fn next(&self) -> io::Result<Option<RedditSearch<'r, 's, T>>> {
        Ok(if let Some(next) = &self.after {
            Some(Self::search(self.params.clone(), None, Some(next)).await?)
        } else {
            None
        })
    }

    /// Previous page of results
    pub async fn prev(&self) -> io::Result<Option<RedditSearch<'r, 's, T>>> {
        Ok(if let Some(prev) = &self.before {
            Some(Self::search(self.params.clone(), Some(prev), None).await?)
        } else {
            None
        })
    }
}