1 use actix_web::{error::ErrorBadRequest, *};
3 use chrono::{DateTime, NaiveDateTime, Utc};
4 use diesel::PgConnection;
5 use lemmy_api_common::utils::blocking;
8 source::{community::Community, local_user::LocalUser, person::Person},
9 traits::{ApubActor, Crud},
14 comment_view::CommentQueryBuilder,
15 post_view::PostQueryBuilder,
16 structs::{CommentView, PostView, SiteView},
18 use lemmy_db_views_actor::{
19 person_mention_view::PersonMentionQueryBuilder,
20 structs::PersonMentionView,
22 use lemmy_utils::{claims::Claims, error::LemmyError, utils::markdown_to_html};
23 use lemmy_websocket::LemmyContext;
24 use once_cell::sync::Lazy;
26 extension::dublincore::DublinCoreExtensionBuilder,
32 use serde::Deserialize;
33 use std::{collections::BTreeMap, str::FromStr};
34 use strum::ParseError;
36 #[derive(Deserialize)]
48 pub fn config(cfg: &mut web::ServiceConfig) {
50 .route("/feeds/{type}/{name}.xml", web::get().to(get_feed))
51 .route("/feeds/all.xml", web::get().to(get_all_feed))
52 .route("/feeds/local.xml", web::get().to(get_local_feed));
55 static RSS_NAMESPACE: Lazy<BTreeMap<String, String>> = Lazy::new(|| {
56 let mut h = BTreeMap::new();
59 rss::extension::dublincore::NAMESPACE.to_string(),
64 #[tracing::instrument(skip_all)]
65 async fn get_all_feed(
66 info: web::Query<Params>,
67 context: web::Data<LemmyContext>,
68 ) -> Result<HttpResponse, Error> {
69 let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
70 Ok(get_feed_data(&context, ListingType::All, sort_type).await?)
73 #[tracing::instrument(skip_all)]
74 async fn get_local_feed(
75 info: web::Query<Params>,
76 context: web::Data<LemmyContext>,
77 ) -> Result<HttpResponse, Error> {
78 let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
79 Ok(get_feed_data(&context, ListingType::Local, sort_type).await?)
82 #[tracing::instrument(skip_all)]
83 async fn get_feed_data(
84 context: &LemmyContext,
85 listing_type: ListingType,
87 ) -> Result<HttpResponse, LemmyError> {
88 let site_view = blocking(context.pool(), SiteView::read_local).await??;
90 let posts = blocking(context.pool(), move |conn| {
91 PostQueryBuilder::create(conn)
92 .listing_type(listing_type)
98 let items = create_post_items(posts, &context.settings().get_protocol_and_hostname())?;
100 let mut channel_builder = ChannelBuilder::default();
102 .namespaces(RSS_NAMESPACE.to_owned())
103 .title(&format!("{} - {}", site_view.site.name, listing_type))
104 .link(context.settings().get_protocol_and_hostname())
107 if let Some(site_desc) = site_view.site.description {
108 channel_builder.description(&site_desc);
111 let rss = channel_builder.build().to_string();
114 .content_type("application/rss+xml")
119 #[tracing::instrument(skip_all)]
122 info: web::Query<Params>,
123 context: web::Data<LemmyContext>,
124 ) -> Result<HttpResponse, Error> {
125 let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
127 let req_type: String = req.match_info().get("type").unwrap_or("none").parse()?;
128 let param: String = req.match_info().get("name").unwrap_or("none").parse()?;
130 let request_type = match req_type.as_str() {
131 "u" => RequestType::User,
132 "c" => RequestType::Community,
133 "front" => RequestType::Front,
134 "inbox" => RequestType::Inbox,
135 _ => return Err(ErrorBadRequest(LemmyError::from(anyhow!("wrong_type")))),
138 let jwt_secret = context.secret().jwt_secret.to_owned();
139 let protocol_and_hostname = context.settings().get_protocol_and_hostname();
141 let builder = blocking(context.pool(), move |conn| match request_type {
142 RequestType::User => get_feed_user(conn, &sort_type, ¶m, &protocol_and_hostname),
143 RequestType::Community => get_feed_community(conn, &sort_type, ¶m, &protocol_and_hostname),
144 RequestType::Front => get_feed_front(
149 &protocol_and_hostname,
151 RequestType::Inbox => get_feed_inbox(conn, &jwt_secret, ¶m, &protocol_and_hostname),
154 .map_err(ErrorBadRequest)?;
156 let rss = builder.build().to_string();
160 .content_type("application/rss+xml")
165 fn get_sort_type(info: web::Query<Params>) -> Result<SortType, ParseError> {
166 let sort_query = info
169 .unwrap_or_else(|| SortType::Hot.to_string());
170 SortType::from_str(&sort_query)
173 #[tracing::instrument(skip_all)]
176 sort_type: &SortType,
178 protocol_and_hostname: &str,
179 ) -> Result<ChannelBuilder, LemmyError> {
180 let site_view = SiteView::read_local(conn)?;
181 let person = Person::read_from_name(conn, user_name)?;
183 let posts = PostQueryBuilder::create(conn)
184 .listing_type(ListingType::All)
186 .creator_id(person.id)
189 let items = create_post_items(posts, protocol_and_hostname)?;
191 let mut channel_builder = ChannelBuilder::default();
193 .namespaces(RSS_NAMESPACE.to_owned())
194 .title(&format!("{} - {}", site_view.site.name, person.name))
195 .link(person.actor_id.to_string())
201 #[tracing::instrument(skip_all)]
202 fn get_feed_community(
204 sort_type: &SortType,
205 community_name: &str,
206 protocol_and_hostname: &str,
207 ) -> Result<ChannelBuilder, LemmyError> {
208 let site_view = SiteView::read_local(conn)?;
209 let community = Community::read_from_name(conn, community_name)?;
211 let posts = PostQueryBuilder::create(conn)
212 .listing_type(ListingType::Community)
214 .community_id(community.id)
217 let items = create_post_items(posts, protocol_and_hostname)?;
219 let mut channel_builder = ChannelBuilder::default();
221 .namespaces(RSS_NAMESPACE.to_owned())
222 .title(&format!("{} - {}", site_view.site.name, community.name))
223 .link(community.actor_id.to_string())
226 if let Some(community_desc) = community.description {
227 channel_builder.description(&community_desc);
233 #[tracing::instrument(skip_all)]
237 sort_type: &SortType,
239 protocol_and_hostname: &str,
240 ) -> Result<ChannelBuilder, LemmyError> {
241 let site_view = SiteView::read_local(conn)?;
242 let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
243 let local_user = LocalUser::read(conn, local_user_id)?;
245 let posts = PostQueryBuilder::create(conn)
246 .listing_type(ListingType::Subscribed)
247 .my_person_id(local_user.person_id)
248 .show_bot_accounts(local_user.show_bot_accounts)
249 .show_read_posts(local_user.show_read_posts)
253 let items = create_post_items(posts, protocol_and_hostname)?;
255 let mut channel_builder = ChannelBuilder::default();
257 .namespaces(RSS_NAMESPACE.to_owned())
258 .title(&format!("{} - Subscribed", site_view.site.name))
259 .link(protocol_and_hostname)
262 if let Some(site_desc) = site_view.site.description {
263 channel_builder.description(&site_desc);
269 #[tracing::instrument(skip_all)]
274 protocol_and_hostname: &str,
275 ) -> Result<ChannelBuilder, LemmyError> {
276 let site_view = SiteView::read_local(conn)?;
277 let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
278 let local_user = LocalUser::read(conn, local_user_id)?;
279 let person_id = local_user.person_id;
280 let show_bot_accounts = local_user.show_bot_accounts;
282 let sort = SortType::New;
284 let replies = CommentQueryBuilder::create(conn)
285 .recipient_id(person_id)
286 .my_person_id(person_id)
287 .show_bot_accounts(show_bot_accounts)
291 let mentions = PersonMentionQueryBuilder::create(conn)
292 .recipient_id(person_id)
293 .my_person_id(person_id)
297 let items = create_reply_and_mention_items(replies, mentions, protocol_and_hostname)?;
299 let mut channel_builder = ChannelBuilder::default();
301 .namespaces(RSS_NAMESPACE.to_owned())
302 .title(&format!("{} - Inbox", site_view.site.name))
303 .link(format!("{}/inbox", protocol_and_hostname,))
306 if let Some(site_desc) = site_view.site.description {
307 channel_builder.description(&site_desc);
313 #[tracing::instrument(skip_all)]
314 fn create_reply_and_mention_items(
315 replies: Vec<CommentView>,
316 mentions: Vec<PersonMentionView>,
317 protocol_and_hostname: &str,
318 ) -> Result<Vec<Item>, LemmyError> {
319 let mut reply_items: Vec<Item> = replies
322 let reply_url = format!(
323 "{}/post/{}/comment/{}",
324 protocol_and_hostname, r.post.id, r.comment.id
328 &r.comment.published,
331 protocol_and_hostname,
334 .collect::<Result<Vec<Item>, LemmyError>>()?;
336 let mut mention_items: Vec<Item> = mentions
339 let mention_url = format!(
340 "{}/post/{}/comment/{}",
341 protocol_and_hostname, m.post.id, m.comment.id
345 &m.comment.published,
348 protocol_and_hostname,
351 .collect::<Result<Vec<Item>, LemmyError>>()?;
353 reply_items.append(&mut mention_items);
357 #[tracing::instrument(skip_all)]
360 published: &NaiveDateTime,
363 protocol_and_hostname: &str,
364 ) -> Result<Item, LemmyError> {
365 let mut i = ItemBuilder::default();
366 i.title(format!("Reply from {}", creator_name));
367 let author_url = format!("{}/u/{}", protocol_and_hostname, creator_name);
369 "/u/{} <a href=\"{}\">(link)</a>",
370 creator_name, author_url
372 let dt = DateTime::<Utc>::from_utc(*published, Utc);
373 i.pub_date(dt.to_rfc2822());
374 i.comments(url.to_owned());
375 let guid = GuidBuilder::default().permalink(true).value(url).build();
377 i.link(url.to_owned());
379 let html = markdown_to_html(content);
384 #[tracing::instrument(skip_all)]
385 fn create_post_items(
386 posts: Vec<PostView>,
387 protocol_and_hostname: &str,
388 ) -> Result<Vec<Item>, LemmyError> {
389 let mut items: Vec<Item> = Vec::new();
392 let mut i = ItemBuilder::default();
393 let mut dc_extension = DublinCoreExtensionBuilder::default();
395 i.title(p.post.name);
397 dc_extension.creators(vec![p.creator.actor_id.to_string()]);
399 let dt = DateTime::<Utc>::from_utc(p.post.published, Utc);
400 i.pub_date(dt.to_rfc2822());
402 let post_url = format!("{}/post/{}", protocol_and_hostname, p.post.id);
403 i.link(post_url.to_owned());
404 i.comments(post_url.to_owned());
405 let guid = GuidBuilder::default()
411 let community_url = format!("{}/c/{}", protocol_and_hostname, p.community.name);
414 let mut description = format!("submitted by <a href=\"{}\">{}</a> to <a href=\"{}\">{}</a><br>{} points | <a href=\"{}\">{} comments</a>",
423 // If its a url post, add it to the description
424 if let Some(url) = p.post.url {
425 let link_html = format!("<br><a href=\"{url}\">{url}</a>", url = url);
426 description.push_str(&link_html);
429 if let Some(body) = p.post.body {
430 let html = markdown_to_html(&body);
431 description.push_str(&html);
434 i.description(description);
436 i.dublin_core_ext(dc_extension.build());
437 items.push(i.build());