qbit_rs/endpoint/
rss.rs

1use serde::Serialize;
2
3use crate::{Qbit, Result, ext::*};
4
5impl Qbit {
6    /// Add a folder to the RSS hierarchy.
7    pub async fn add_folder<T: AsRef<str> + Send + Sync>(&self, path: T) -> Result<()> {
8        #[derive(Serialize)]
9        struct Arg<'a> {
10            path: &'a str,
11        }
12
13        self.post_with(
14            "rss/addFolder",
15            &Arg {
16                path: path.as_ref(),
17            },
18        )
19        .await?
20        .end()
21    }
22
23    /// Add an RSS feed, optionally under the supplied folder.
24    pub async fn add_feed<T: AsRef<str> + Send + Sync>(
25        &self,
26        url: T,
27        path: Option<T>,
28    ) -> Result<()> {
29        #[derive(Serialize)]
30        struct Arg<'a> {
31            url: &'a str,
32            path: Option<&'a str>,
33        }
34
35        self.post_with(
36            "rss/addFeed",
37            &Arg {
38                url: url.as_ref(),
39                path: path.as_ref().map(AsRef::as_ref),
40            },
41        )
42        .await?
43        .end()
44    }
45
46    /// Remove an RSS feed or folder.
47    pub async fn remove_item<T: AsRef<str> + Send + Sync>(&self, path: T) -> Result<()> {
48        #[derive(Serialize)]
49        struct Arg<'a> {
50            path: &'a str,
51        }
52
53        self.post_with(
54            "rss/removeItem",
55            &Arg {
56                path: path.as_ref(),
57            },
58        )
59        .await?
60        .end()
61    }
62
63    /// Move an RSS feed or folder to another path.
64    pub async fn move_item<T: AsRef<str> + Send + Sync>(
65        &self,
66        item_path: T,
67        dest_path: T,
68    ) -> Result<()> {
69        #[derive(Serialize)]
70        #[serde(rename_all = "camelCase")]
71        struct Arg<'a> {
72            item_path: &'a str,
73            dest_path: &'a str,
74        }
75
76        self.post_with(
77            "rss/moveItem",
78            &Arg {
79                item_path: item_path.as_ref(),
80                dest_path: dest_path.as_ref(),
81            },
82        )
83        .await?
84        .end()
85    }
86
87    /// Mark an RSS item or article as read.
88    pub async fn mark_as_read<T: AsRef<str> + Send + Sync>(
89        &self,
90        item_path: T,
91        article_id: Option<T>,
92    ) -> Result<()> {
93        #[derive(Serialize)]
94        #[serde(rename_all = "camelCase")]
95        struct Arg<'a> {
96            item_path: &'a str,
97            article_id: Option<&'a str>,
98        }
99
100        self.post_with(
101            "rss/markAsRead",
102            &Arg {
103                item_path: item_path.as_ref(),
104                article_id: article_id.as_ref().map(AsRef::as_ref),
105            },
106        )
107        .await?
108        .end()
109    }
110
111    /// Refresh an RSS feed or folder.
112    pub async fn refresh_item<T: AsRef<str> + Send + Sync>(&self, item_path: T) -> Result<()> {
113        #[derive(Serialize)]
114        #[serde(rename_all = "camelCase")]
115        struct Arg<'a> {
116            item_path: &'a str,
117        }
118
119        self.post_with(
120            "rss/refreshItem",
121            &Arg {
122                item_path: item_path.as_ref(),
123            },
124        )
125        .await?
126        .end()
127    }
128
129    /// Rename an RSS auto-downloading rule.
130    pub async fn rename_rule<T: AsRef<str> + Send + Sync>(
131        &self,
132        rule_name: T,
133        new_rule_name: T,
134    ) -> Result<()> {
135        #[derive(Serialize)]
136        #[serde(rename_all = "camelCase")]
137        struct Arg<'a> {
138            rule_name: &'a str,
139            new_rule_name: &'a str,
140        }
141
142        self.post_with(
143            "rss/renameRule",
144            &Arg {
145                rule_name: rule_name.as_ref(),
146                new_rule_name: new_rule_name.as_ref(),
147            },
148        )
149        .await?
150        .end()
151    }
152
153    /// Remove an RSS auto-downloading rule.
154    pub async fn remove_rule<T: AsRef<str> + Send + Sync>(&self, rule_name: T) -> Result<()> {
155        #[derive(Serialize)]
156        #[serde(rename_all = "camelCase")]
157        struct Arg<'a> {
158            rule_name: &'a str,
159        }
160
161        self.post_with(
162            "rss/removeRule",
163            &Arg {
164                rule_name: rule_name.as_ref(),
165            },
166        )
167        .await?
168        .end()
169    }
170}
qbit_rs/endpoint/rss.rs

qbit_rs/endpoint/
rss.rs
