rive-http 1.1.1

Revolt REST API client for the Rive ecosystem.
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

use crate::prelude::*;
use rive_models::{
    data::{CreateStrikeData, EditAccountStrikeData, EditReportData, ReportContentData},
    report::Report,
    snapshot::Snapshot,
    strike::AccountStrike,
};

impl Client {
    /// Edit a report.
    pub async fn edit_report(
        &self,
        report: impl Into<String>,
        data: EditReportData,
    ) -> Result<Report> {
        Ok(self
            .client
            .patch(ep!(self, "/safety/reports/{}", report.into()))
            .auth(&self.authentication)
            .json(&data)
            .send()
            .await?
            .process_error()
            .await?
            .json()
            .await?)
    }

    /// Fetch a report by its ID.
    pub async fn fetch_report(&self, id: impl Into<String>) -> Result<Report> {
        Ok(self
            .client
            .get(ep!(self, "/safety/report/{}", id.into()))
            .auth(&self.authentication)
            .send()
            .await?
            .process_error()
            .await?
            .json()
            .await?)
    }

    /// Fetch all available reports
    pub async fn fetch_reports(&self) -> Result<Vec<Report>> {
        Ok(self
            .client
            .get(ep!(self, "/safety/reports"))
            .auth(&self.authentication)
            .send()
            .await?
            .process_error()
            .await?
            .json()
            .await?)
    }

    /// Report a piece of content to the moderation team.
    pub async fn report_content(&self, data: ReportContentData) -> Result<()> {
        self.client
            .post(ep!(self, "/safety/report"))
            .json(&data)
            .auth(&self.authentication)
            .send()
            .await?
            .process_error()
            .await?;
        Ok(())
    }

    /// Fetch a snapshot for a given report.
    pub async fn fetch_snapshot(&self, report_id: impl Into<String>) -> Result<Snapshot> {
        Ok(self
            .client
            .get(ep!(self, "/safety/snapshot/{}", report_id.into()))
            .auth(&self.authentication)
            .send()
            .await?
            .process_error()
            .await?
            .json()
            .await?)
    }

    /// Create a new account strike.
    pub async fn create_strike(&self, data: CreateStrikeData) -> Result<AccountStrike> {
        Ok(self
            .client
            .post(ep!(self, "/safety/strikes"))
            .auth(&self.authentication)
            .json(&data)
            .send()
            .await?
            .json()
            .await?)
    }

    /// Fetch strikes for a user by their ID.
    pub async fn fetch_strikes(&self, user_id: impl Into<String>) -> Result<AccountStrike> {
        Ok(self
            .client
            .get(ep!(self, "/safety/strikes/{}", user_id.into()))
            .auth(&self.authentication)
            .send()
            .await?
            .json()
            .await?)
    }

    /// Edit a strike by its ID.
    pub async fn edit_strike(
        &self,
        strike_id: impl Into<String>,
        data: EditAccountStrikeData,
    ) -> Result<()> {
        self.client
            .patch(ep!(self, "/safety/strikes/{}", strike_id.into()))
            .auth(&self.authentication)
            .json(&data)
            .send()
            .await?
            .json::<()>()
            .await?;
        Ok(())
    }

    /// Edit a strike by its ID.
    pub async fn delete_strike(&self, strike_id: impl Into<String>) -> Result<()> {
        self.client
            .delete(ep!(self, "/safety/strikes/{}", strike_id.into()))
            .auth(&self.authentication)
            .send()
            .await?
            .json::<()>()
            .await?;
        Ok(())
    }
}