1 use actix_web::{error::ErrorBadRequest, web, Error, HttpRequest, HttpResponse, Result};
3 use chrono::{DateTime, NaiveDateTime, Utc};
4 use lemmy_api_common::context::LemmyContext;
7 source::{community::Community, local_user::LocalUser, person::Person},
8 traits::{ApubActor, Crud},
16 structs::{PostView, SiteView},
18 use lemmy_db_views_actor::{
19 comment_reply_view::CommentReplyQuery,
20 person_mention_view::PersonMentionQuery,
21 structs::{CommentReplyView, PersonMentionView},
23 use lemmy_utils::{claims::Claims, error::LemmyError, utils::markdown::markdown_to_html};
24 use once_cell::sync::Lazy;
26 extension::dublincore::DublinCoreExtensionBuilder,
32 use serde::Deserialize;
33 use std::{collections::BTreeMap, str::FromStr};
35 const RSS_FETCH_LIMIT: i64 = 20;
37 #[derive(Deserialize)]
45 fn sort_type(&self) -> Result<SortType, Error> {
49 .unwrap_or_else(|| SortType::Hot.to_string());
50 SortType::from_str(&sort_query).map_err(ErrorBadRequest)
52 fn get_limit(&self) -> i64 {
53 self.limit.unwrap_or(RSS_FETCH_LIMIT)
55 fn get_page(&self) -> i64 {
56 self.page.unwrap_or(1)
67 pub fn config(cfg: &mut web::ServiceConfig) {
69 .route("/feeds/{type}/{name}.xml", web::get().to(get_feed))
70 .route("/feeds/all.xml", web::get().to(get_all_feed))
71 .route("/feeds/local.xml", web::get().to(get_local_feed));
74 static RSS_NAMESPACE: Lazy<BTreeMap<String, String>> = Lazy::new(|| {
75 let mut h = BTreeMap::new();
78 rss::extension::dublincore::NAMESPACE.to_string(),
83 #[tracing::instrument(skip_all)]
84 async fn get_all_feed(
85 info: web::Query<Params>,
86 context: web::Data<LemmyContext>,
87 ) -> Result<HttpResponse, Error> {
100 #[tracing::instrument(skip_all)]
101 async fn get_local_feed(
102 info: web::Query<Params>,
103 context: web::Data<LemmyContext>,
104 ) -> Result<HttpResponse, Error> {
117 #[tracing::instrument(skip_all)]
118 async fn get_feed_data(
119 context: &LemmyContext,
120 listing_type: ListingType,
124 ) -> Result<HttpResponse, LemmyError> {
125 let site_view = SiteView::read_local(context.pool()).await?;
127 let posts = PostQuery::builder()
128 .pool(context.pool())
129 .listing_type(Some(listing_type))
130 .sort(Some(sort_type))
137 let items = create_post_items(posts, &context.settings().get_protocol_and_hostname())?;
139 let mut channel_builder = ChannelBuilder::default();
141 .namespaces(RSS_NAMESPACE.clone())
142 .title(&format!("{} - {}", site_view.site.name, listing_type))
143 .link(context.settings().get_protocol_and_hostname())
146 if let Some(site_desc) = site_view.site.description {
147 channel_builder.description(&site_desc);
150 let rss = channel_builder.build().to_string();
153 .content_type("application/rss+xml")
158 #[tracing::instrument(skip_all)]
161 info: web::Query<Params>,
162 context: web::Data<LemmyContext>,
163 ) -> Result<HttpResponse, Error> {
164 let req_type: String = req.match_info().get("type").unwrap_or("none").parse()?;
165 let param: String = req.match_info().get("name").unwrap_or("none").parse()?;
167 let request_type = match req_type.as_str() {
168 "u" => RequestType::User,
169 "c" => RequestType::Community,
170 "front" => RequestType::Front,
171 "inbox" => RequestType::Inbox,
172 _ => return Err(ErrorBadRequest(LemmyError::from(anyhow!("wrong_type")))),
175 let jwt_secret = context.secret().jwt_secret.clone();
176 let protocol_and_hostname = context.settings().get_protocol_and_hostname();
178 let builder = match request_type {
179 RequestType::User => {
186 &protocol_and_hostname,
190 RequestType::Community => {
197 &protocol_and_hostname,
201 RequestType::Front => {
209 &protocol_and_hostname,
213 RequestType::Inbox => {
214 get_feed_inbox(context.pool(), &jwt_secret, ¶m, &protocol_and_hostname).await
217 .map_err(ErrorBadRequest)?;
219 let rss = builder.build().to_string();
223 .content_type("application/rss+xml")
228 #[tracing::instrument(skip_all)]
229 async fn get_feed_user(
231 sort_type: &SortType,
235 protocol_and_hostname: &str,
236 ) -> Result<ChannelBuilder, LemmyError> {
237 let site_view = SiteView::read_local(pool).await?;
238 let person = Person::read_from_name(pool, user_name, false).await?;
240 let posts = PostQuery::builder()
242 .listing_type(Some(ListingType::All))
243 .sort(Some(*sort_type))
244 .creator_id(Some(person.id))
251 let items = create_post_items(posts, protocol_and_hostname)?;
253 let mut channel_builder = ChannelBuilder::default();
255 .namespaces(RSS_NAMESPACE.clone())
256 .title(&format!("{} - {}", site_view.site.name, person.name))
257 .link(person.actor_id.to_string())
263 #[tracing::instrument(skip_all)]
264 async fn get_feed_community(
266 sort_type: &SortType,
269 community_name: &str,
270 protocol_and_hostname: &str,
271 ) -> Result<ChannelBuilder, LemmyError> {
272 let site_view = SiteView::read_local(pool).await?;
273 let community = Community::read_from_name(pool, community_name, false).await?;
275 let posts = PostQuery::builder()
277 .sort(Some(*sort_type))
278 .community_id(Some(community.id))
285 let items = create_post_items(posts, protocol_and_hostname)?;
287 let mut channel_builder = ChannelBuilder::default();
289 .namespaces(RSS_NAMESPACE.clone())
290 .title(&format!("{} - {}", site_view.site.name, community.name))
291 .link(community.actor_id.to_string())
294 if let Some(community_desc) = community.description {
295 channel_builder.description(&community_desc);
301 #[tracing::instrument(skip_all)]
302 async fn get_feed_front(
305 sort_type: &SortType,
309 protocol_and_hostname: &str,
310 ) -> Result<ChannelBuilder, LemmyError> {
311 let site_view = SiteView::read_local(pool).await?;
312 let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
313 let local_user = LocalUser::read(pool, local_user_id).await?;
315 let posts = PostQuery::builder()
317 .listing_type(Some(ListingType::Subscribed))
318 .local_user(Some(&local_user))
319 .sort(Some(*sort_type))
326 let items = create_post_items(posts, protocol_and_hostname)?;
328 let mut channel_builder = ChannelBuilder::default();
330 .namespaces(RSS_NAMESPACE.clone())
331 .title(&format!("{} - Subscribed", site_view.site.name))
332 .link(protocol_and_hostname)
335 if let Some(site_desc) = site_view.site.description {
336 channel_builder.description(&site_desc);
342 #[tracing::instrument(skip_all)]
343 async fn get_feed_inbox(
347 protocol_and_hostname: &str,
348 ) -> Result<ChannelBuilder, LemmyError> {
349 let site_view = SiteView::read_local(pool).await?;
350 let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
351 let local_user = LocalUser::read(pool, local_user_id).await?;
352 let person_id = local_user.person_id;
353 let show_bot_accounts = local_user.show_bot_accounts;
355 let sort = CommentSortType::New;
357 let replies = CommentReplyQuery::builder()
359 .recipient_id(Some(person_id))
360 .my_person_id(Some(person_id))
361 .show_bot_accounts(Some(show_bot_accounts))
363 .limit(Some(RSS_FETCH_LIMIT))
368 let mentions = PersonMentionQuery::builder()
370 .recipient_id(Some(person_id))
371 .my_person_id(Some(person_id))
372 .show_bot_accounts(Some(show_bot_accounts))
374 .limit(Some(RSS_FETCH_LIMIT))
379 let items = create_reply_and_mention_items(replies, mentions, protocol_and_hostname)?;
381 let mut channel_builder = ChannelBuilder::default();
383 .namespaces(RSS_NAMESPACE.clone())
384 .title(&format!("{} - Inbox", site_view.site.name))
385 .link(format!("{protocol_and_hostname}/inbox",))
388 if let Some(site_desc) = site_view.site.description {
389 channel_builder.description(&site_desc);
395 #[tracing::instrument(skip_all)]
396 fn create_reply_and_mention_items(
397 replies: Vec<CommentReplyView>,
398 mentions: Vec<PersonMentionView>,
399 protocol_and_hostname: &str,
400 ) -> Result<Vec<Item>, LemmyError> {
401 let mut reply_items: Vec<Item> = replies
404 let reply_url = format!(
405 "{}/post/{}/comment/{}",
406 protocol_and_hostname, r.post.id, r.comment.id
410 &r.comment.published,
413 protocol_and_hostname,
416 .collect::<Result<Vec<Item>, LemmyError>>()?;
418 let mut mention_items: Vec<Item> = mentions
421 let mention_url = format!(
422 "{}/post/{}/comment/{}",
423 protocol_and_hostname, m.post.id, m.comment.id
427 &m.comment.published,
430 protocol_and_hostname,
433 .collect::<Result<Vec<Item>, LemmyError>>()?;
435 reply_items.append(&mut mention_items);
439 #[tracing::instrument(skip_all)]
442 published: &NaiveDateTime,
445 protocol_and_hostname: &str,
446 ) -> Result<Item, LemmyError> {
447 let mut i = ItemBuilder::default();
448 i.title(format!("Reply from {creator_name}"));
449 let author_url = format!("{protocol_and_hostname}/u/{creator_name}");
451 "/u/{creator_name} <a href=\"{author_url}\">(link)</a>"
453 let dt = DateTime::<Utc>::from_utc(*published, Utc);
454 i.pub_date(dt.to_rfc2822());
455 i.comments(url.to_owned());
456 let guid = GuidBuilder::default().permalink(true).value(url).build();
458 i.link(url.to_owned());
460 let html = markdown_to_html(content);
465 #[tracing::instrument(skip_all)]
466 fn create_post_items(
467 posts: Vec<PostView>,
468 protocol_and_hostname: &str,
469 ) -> Result<Vec<Item>, LemmyError> {
470 let mut items: Vec<Item> = Vec::new();
473 let mut i = ItemBuilder::default();
474 let mut dc_extension = DublinCoreExtensionBuilder::default();
476 i.title(p.post.name);
478 dc_extension.creators(vec![p.creator.actor_id.to_string()]);
480 let dt = DateTime::<Utc>::from_utc(p.post.published, Utc);
481 i.pub_date(dt.to_rfc2822());
483 let post_url = format!("{}/post/{}", protocol_and_hostname, p.post.id);
484 i.link(post_url.clone());
485 i.comments(post_url.clone());
486 let guid = GuidBuilder::default()
492 let community_url = format!("{}/c/{}", protocol_and_hostname, p.community.name);
495 let mut description = format!("submitted by <a href=\"{}\">{}</a> to <a href=\"{}\">{}</a><br>{} points | <a href=\"{}\">{} comments</a>",
504 // If its a url post, add it to the description
505 if let Some(url) = p.post.url {
506 let link_html = format!("<br><a href=\"{url}\">{url}</a>");
507 description.push_str(&link_html);
510 if let Some(body) = p.post.body {
511 let html = markdown_to_html(&body);
512 description.push_str(&html);
515 i.description(description);
517 i.dublin_core_ext(dc_extension.build());
518 items.push(i.build());