rraw 1.2.1

An async Rust Reddit API Wrapper
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

use crate::auth::Authorized;
use crate::comments::response::CommentsResponse;
use crate::error::Error;
use crate::message::response::MessageListing;
use crate::message::WhereMessage;
use crate::responses::FullName;
use crate::Client;
use serde_json::Value;

use crate::responses::listing::RedditListing;
use crate::submission::response::SubmissionsResponse;
use crate::subreddit::response::Friend;
use crate::user::response::MeResponse;

use crate::utils::options::FeedOption;

/// The User Object for Reddit
pub struct Me<'a, A: Authorized> {
    pub(crate) client: &'a Client<A>,
    pub me: MeResponse,
}

impl<'a, A: Authorized> Me<'a, A> {
    /// For blocking the author of a thing via inbox. - Reddit API
    pub async fn block_author(&self, full_name: FullName) -> Result<Friend, Error> {
        let body = reqwest::Body::from(format!("id={}", full_name));
        self.client
            .post_json::<Friend>("/api/block", true, body)
            .await
    }
    /// Gets the Messages. Default for where_message is Inbox
    pub async fn get_messages(
        &self,
        where_message: Option<WhereMessage>,
        feed: Option<FeedOption>,
    ) -> Result<MessageListing, Error> {
        let mut string = format!("/message/{}", where_message.unwrap_or(WhereMessage::Inbox));
        if let Some(f) = feed {
            f.extend(&mut string);
        }
        self.client
            .get_json::<MessageListing>(&string, true, false)
            .await
    }
    /// Composes a message.
    pub async fn compose(
        &self,
        recipient: String,
        subject: String,
        body: String,
    ) -> Result<Value, Error> {
        let string = format!("api_type=json&subject={subject}&text={body}&to={recipient}");
        let body = reqwest::Body::from(string);
        self.client
            .post_json::<Value>("/api/compose", true, body)
            .await
    }

    /// Comments
    pub async fn comments(&self, feed: Option<FeedOption>) -> Result<CommentsResponse, Error> {
        let mut string = format!("/user/{}/comments", &self.me.about.name);
        if let Some(options) = feed {
            string.push('?');
            string.push_str(options.url().as_str());
        }
        self.client
            .get_json::<CommentsResponse>(&*string, false, false)
            .await
    }
    /// user Submissions
    pub async fn submissions(
        &self,
        feed: Option<FeedOption>,
    ) -> Result<SubmissionsResponse, Error> {
        let mut string = format!("/user/{}/submitted", &self.me.about.name);
        if let Some(options) = feed {
            string.push('?');
            string.push_str(options.url().as_str());
        }
        self.client
            .get_json::<SubmissionsResponse>(&*string, false, false)
            .await
    }

    /// User Overview
    pub async fn overview(&self, feed: Option<FeedOption>) -> Result<RedditListing, Error> {
        let mut string = format!("/user/{}/overview", &self.me.about.name);
        if let Some(options) = feed {
            string.push('?');
            string.push_str(options.url().as_str());
        }
        self.client
            .get_json::<RedditListing>(&*string, false, false)
            .await
    }
    pub async fn saved(&self, feed: Option<FeedOption>) -> Result<RedditListing, Error> {
        let mut string = format!("/user/{}/saved", &self.me.about.name);
        if let Some(options) = feed {
            string.push('?');
            string.push_str(options.url().as_str());
        }
        self.client
            .get_json::<RedditListing>(&*string, false, false)
            .await
    }
    pub async fn up_voted(&self, feed: Option<FeedOption>) -> Result<RedditListing, Error> {
        let mut string = format!("/user/{}/upvoted", &self.me.about.name);
        if let Some(options) = feed {
            string.push('?');
            string.push_str(options.url().as_str());
        }
        self.client
            .get_json::<RedditListing>(&string, false, false)
            .await
    }
    pub async fn down_voted(&self, feed: Option<FeedOption>) -> Result<RedditListing, Error> {
        let mut string = format!("/user/{}/downvoted", &self.me.about.name);
        if let Some(options) = feed {
            string.push('?');
            string.push_str(options.url().as_str());
        }
        self.client
            .get_json::<RedditListing>(&string, false, false)
            .await
    }
}