crates/routes/src/feeds.rs

   1 use actix_web::{error::ErrorBadRequest, web, Error, HttpRequest, HttpResponse, Result};
   2 use anyhow::anyhow;
   3 use chrono::{DateTime, NaiveDateTime, Utc};
   4 use lemmy_api_common::context::LemmyContext;
   5 use lemmy_db_schema::{
   6   newtypes::LocalUserId,
   7   source::{community::Community, local_user::LocalUser, person::Person},
   8   traits::{ApubActor, Crud},
   9   utils::DbPool,
  10   CommentSortType,
  11   ListingType,
  12   SortType,
  13 };
  14 use lemmy_db_views::{
  15   post_view::PostQuery,
  16   structs::{PostView, SiteView},
  17 };
  18 use lemmy_db_views_actor::{
  19   comment_reply_view::CommentReplyQuery,
  20   person_mention_view::PersonMentionQuery,
  21   structs::{CommentReplyView, PersonMentionView},
  22 };
  23 use lemmy_utils::{claims::Claims, error::LemmyError, utils::markdown::markdown_to_html};
  24 use once_cell::sync::Lazy;
  25 use rss::{
  26   extension::dublincore::DublinCoreExtensionBuilder,
  27   ChannelBuilder,
  28   GuidBuilder,
  29   Item,
  30   ItemBuilder,
  31 };
  32 use serde::Deserialize;
  33 use std::{collections::BTreeMap, str::FromStr};
  34
  35 const RSS_FETCH_LIMIT: i64 = 20;
  36
  37 #[derive(Deserialize)]
  38 struct Params {
  39   sort: Option<String>,
  40   limit: Option<i64>,
  41   page: Option<i64>,
  42 }
  43
  44 impl Params {
  45   fn sort_type(&self) -> Result<SortType, Error> {
  46     let sort_query = self
  47       .sort
  48       .clone()
  49       .unwrap_or_else(|| SortType::Hot.to_string());
  50     SortType::from_str(&sort_query).map_err(ErrorBadRequest)
  51   }
  52   fn get_limit(&self) -> i64 {
  53     self.limit.unwrap_or(RSS_FETCH_LIMIT)
  54   }
  55   fn get_page(&self) -> i64 {
  56     self.page.unwrap_or(1)
  57   }
  58 }
  59
  60 enum RequestType {
  61   Community,
  62   User,
  63   Front,
  64   Inbox,
  65 }
  66
  67 pub fn config(cfg: &mut web::ServiceConfig) {
  68   cfg
  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));
  72 }
  73
  74 static RSS_NAMESPACE: Lazy<BTreeMap<String, String>> = Lazy::new(|| {
  75   let mut h = BTreeMap::new();
  76   h.insert(
  77     "dc".to_string(),
  78     rss::extension::dublincore::NAMESPACE.to_string(),
  79   );
  80   h
  81 });
  82
  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> {
  88   Ok(
  89     get_feed_data(
  90       &context,
  91       ListingType::All,
  92       info.sort_type()?,
  93       info.get_limit(),
  94       info.get_page(),
  95     )
  96     .await?,
  97   )
  98 }
  99
 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> {
 105   Ok(
 106     get_feed_data(
 107       &context,
 108       ListingType::Local,
 109       info.sort_type()?,
 110       info.get_limit(),
 111       info.get_page(),
 112     )
 113     .await?,
 114   )
 115 }
 116
 117 #[tracing::instrument(skip_all)]
 118 async fn get_feed_data(
 119   context: &LemmyContext,
 120   listing_type: ListingType,
 121   sort_type: SortType,
 122   limit: i64,
 123   page: i64,
 124 ) -> Result<HttpResponse, LemmyError> {
 125   let site_view = SiteView::read_local(context.pool()).await?;
 126
 127   let posts = PostQuery::builder()
 128     .pool(context.pool())
 129     .listing_type(Some(listing_type))
 130     .sort(Some(sort_type))
 131     .limit(Some(limit))
 132     .page(Some(page))
 133     .build()
 134     .list()
 135     .await?;
 136
 137   let items = create_post_items(posts, &context.settings().get_protocol_and_hostname())?;
 138
 139   let mut channel_builder = ChannelBuilder::default();
 140   channel_builder
 141     .namespaces(RSS_NAMESPACE.clone())
 142     .title(&format!("{} - {}", site_view.site.name, listing_type))
 143     .link(context.settings().get_protocol_and_hostname())
 144     .items(items);
 145
 146   if let Some(site_desc) = site_view.site.description {
 147     channel_builder.description(&site_desc);
 148   }
 149
 150   let rss = channel_builder.build().to_string();
 151   Ok(
 152     HttpResponse::Ok()
 153       .content_type("application/rss+xml")
 154       .body(rss),
 155   )
 156 }
 157
 158 #[tracing::instrument(skip_all)]
 159 async fn get_feed(
 160   req: HttpRequest,
 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()?;
 166
 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")))),
 173   };
 174
 175   let jwt_secret = context.secret().jwt_secret.clone();
 176   let protocol_and_hostname = context.settings().get_protocol_and_hostname();
 177
 178   let builder = match request_type {
 179     RequestType::User => {
 180       get_feed_user(
 181         context.pool(),
 182         &info.sort_type()?,
 183         &info.get_limit(),
 184         &info.get_page(),
 185         &param,
 186         &protocol_and_hostname,
 187       )
 188       .await
 189     }
 190     RequestType::Community => {
 191       get_feed_community(
 192         context.pool(),
 193         &info.sort_type()?,
 194         &info.get_limit(),
 195         &info.get_page(),
 196         &param,
 197         &protocol_and_hostname,
 198       )
 199       .await
 200     }
 201     RequestType::Front => {
 202       get_feed_front(
 203         context.pool(),
 204         &jwt_secret,
 205         &info.sort_type()?,
 206         &info.get_limit(),
 207         &info.get_page(),
 208         &param,
 209         &protocol_and_hostname,
 210       )
 211       .await
 212     }
 213     RequestType::Inbox => {
 214       get_feed_inbox(context.pool(), &jwt_secret, &param, &protocol_and_hostname).await
 215     }
 216   }
 217   .map_err(ErrorBadRequest)?;
 218
 219   let rss = builder.build().to_string();
 220
 221   Ok(
 222     HttpResponse::Ok()
 223       .content_type("application/rss+xml")
 224       .body(rss),
 225   )
 226 }
 227
 228 #[tracing::instrument(skip_all)]
 229 async fn get_feed_user(
 230   pool: &DbPool,
 231   sort_type: &SortType,
 232   limit: &i64,
 233   page: &i64,
 234   user_name: &str,
 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?;
 239
 240   let posts = PostQuery::builder()
 241     .pool(pool)
 242     .listing_type(Some(ListingType::All))
 243     .sort(Some(*sort_type))
 244     .creator_id(Some(person.id))
 245     .limit(Some(*limit))
 246     .page(Some(*page))
 247     .build()
 248     .list()
 249     .await?;
 250
 251   let items = create_post_items(posts, protocol_and_hostname)?;
 252
 253   let mut channel_builder = ChannelBuilder::default();
 254   channel_builder
 255     .namespaces(RSS_NAMESPACE.clone())
 256     .title(&format!("{} - {}", site_view.site.name, person.name))
 257     .link(person.actor_id.to_string())
 258     .items(items);
 259
 260   Ok(channel_builder)
 261 }
 262
 263 #[tracing::instrument(skip_all)]
 264 async fn get_feed_community(
 265   pool: &DbPool,
 266   sort_type: &SortType,
 267   limit: &i64,
 268   page: &i64,
 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?;
 274
 275   let posts = PostQuery::builder()
 276     .pool(pool)
 277     .sort(Some(*sort_type))
 278     .community_id(Some(community.id))
 279     .limit(Some(*limit))
 280     .page(Some(*page))
 281     .build()
 282     .list()
 283     .await?;
 284
 285   let items = create_post_items(posts, protocol_and_hostname)?;
 286
 287   let mut channel_builder = ChannelBuilder::default();
 288   channel_builder
 289     .namespaces(RSS_NAMESPACE.clone())
 290     .title(&format!("{} - {}", site_view.site.name, community.name))
 291     .link(community.actor_id.to_string())
 292     .items(items);
 293
 294   if let Some(community_desc) = community.description {
 295     channel_builder.description(&community_desc);
 296   }
 297
 298   Ok(channel_builder)
 299 }
 300
 301 #[tracing::instrument(skip_all)]
 302 async fn get_feed_front(
 303   pool: &DbPool,
 304   jwt_secret: &str,
 305   sort_type: &SortType,
 306   limit: &i64,
 307   page: &i64,
 308   jwt: &str,
 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?;
 314
 315   let posts = PostQuery::builder()
 316     .pool(pool)
 317     .listing_type(Some(ListingType::Subscribed))
 318     .local_user(Some(&local_user))
 319     .sort(Some(*sort_type))
 320     .limit(Some(*limit))
 321     .page(Some(*page))
 322     .build()
 323     .list()
 324     .await?;
 325
 326   let items = create_post_items(posts, protocol_and_hostname)?;
 327
 328   let mut channel_builder = ChannelBuilder::default();
 329   channel_builder
 330     .namespaces(RSS_NAMESPACE.clone())
 331     .title(&format!("{} - Subscribed", site_view.site.name))
 332     .link(protocol_and_hostname)
 333     .items(items);
 334
 335   if let Some(site_desc) = site_view.site.description {
 336     channel_builder.description(&site_desc);
 337   }
 338
 339   Ok(channel_builder)
 340 }
 341
 342 #[tracing::instrument(skip_all)]
 343 async fn get_feed_inbox(
 344   pool: &DbPool,
 345   jwt_secret: &str,
 346   jwt: &str,
 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;
 354
 355   let sort = CommentSortType::New;
 356
 357   let replies = CommentReplyQuery::builder()
 358     .pool(pool)
 359     .recipient_id(Some(person_id))
 360     .my_person_id(Some(person_id))
 361     .show_bot_accounts(Some(show_bot_accounts))
 362     .sort(Some(sort))
 363     .limit(Some(RSS_FETCH_LIMIT))
 364     .build()
 365     .list()
 366     .await?;
 367
 368   let mentions = PersonMentionQuery::builder()
 369     .pool(pool)
 370     .recipient_id(Some(person_id))
 371     .my_person_id(Some(person_id))
 372     .show_bot_accounts(Some(show_bot_accounts))
 373     .sort(Some(sort))
 374     .limit(Some(RSS_FETCH_LIMIT))
 375     .build()
 376     .list()
 377     .await?;
 378
 379   let items = create_reply_and_mention_items(replies, mentions, protocol_and_hostname)?;
 380
 381   let mut channel_builder = ChannelBuilder::default();
 382   channel_builder
 383     .namespaces(RSS_NAMESPACE.clone())
 384     .title(&format!("{} - Inbox", site_view.site.name))
 385     .link(format!("{protocol_and_hostname}/inbox",))
 386     .items(items);
 387
 388   if let Some(site_desc) = site_view.site.description {
 389     channel_builder.description(&site_desc);
 390   }
 391
 392   Ok(channel_builder)
 393 }
 394
 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
 402     .iter()
 403     .map(|r| {
 404       let reply_url = format!("{}/comment/{}", protocol_and_hostname, r.comment.id);
 405       build_item(
 406         &r.creator.name,
 407         &r.comment.published,
 408         &reply_url,
 409         &r.comment.content,
 410         protocol_and_hostname,
 411       )
 412     })
 413     .collect::<Result<Vec<Item>, LemmyError>>()?;
 414
 415   let mut mention_items: Vec<Item> = mentions
 416     .iter()
 417     .map(|m| {
 418       let mention_url = format!("{}/comment/{}", protocol_and_hostname, m.comment.id);
 419       build_item(
 420         &m.creator.name,
 421         &m.comment.published,
 422         &mention_url,
 423         &m.comment.content,
 424         protocol_and_hostname,
 425       )
 426     })
 427     .collect::<Result<Vec<Item>, LemmyError>>()?;
 428
 429   reply_items.append(&mut mention_items);
 430   Ok(reply_items)
 431 }
 432
 433 #[tracing::instrument(skip_all)]
 434 fn build_item(
 435   creator_name: &str,
 436   published: &NaiveDateTime,
 437   url: &str,
 438   content: &str,
 439   protocol_and_hostname: &str,
 440 ) -> Result<Item, LemmyError> {
 441   let mut i = ItemBuilder::default();
 442   i.title(format!("Reply from {creator_name}"));
 443   let author_url = format!("{protocol_and_hostname}/u/{creator_name}");
 444   i.author(format!(
 445     "/u/{creator_name} <a href=\"{author_url}\">(link)</a>"
 446   ));
 447   let dt = DateTime::<Utc>::from_utc(*published, Utc);
 448   i.pub_date(dt.to_rfc2822());
 449   i.comments(url.to_owned());
 450   let guid = GuidBuilder::default().permalink(true).value(url).build();
 451   i.guid(guid);
 452   i.link(url.to_owned());
 453   // TODO add images
 454   let html = markdown_to_html(content);
 455   i.description(html);
 456   Ok(i.build())
 457 }
 458
 459 #[tracing::instrument(skip_all)]
 460 fn create_post_items(
 461   posts: Vec<PostView>,
 462   protocol_and_hostname: &str,
 463 ) -> Result<Vec<Item>, LemmyError> {
 464   let mut items: Vec<Item> = Vec::new();
 465
 466   for p in posts {
 467     let mut i = ItemBuilder::default();
 468     let mut dc_extension = DublinCoreExtensionBuilder::default();
 469
 470     i.title(p.post.name);
 471
 472     dc_extension.creators(vec![p.creator.actor_id.to_string()]);
 473
 474     let dt = DateTime::<Utc>::from_utc(p.post.published, Utc);
 475     i.pub_date(dt.to_rfc2822());
 476
 477     let post_url = format!("{}/post/{}", protocol_and_hostname, p.post.id);
 478     i.link(post_url.clone());
 479     i.comments(post_url.clone());
 480     let guid = GuidBuilder::default()
 481       .permalink(true)
 482       .value(&post_url)
 483       .build();
 484     i.guid(guid);
 485
 486     let community_url = format!("{}/c/{}", protocol_and_hostname, p.community.name);
 487
 488     // TODO add images
 489     let mut description = format!("submitted by <a href=\"{}\">{}</a> to <a href=\"{}\">{}</a><br>{} points | <a href=\"{}\">{} comments</a>",
 490     p.creator.actor_id,
 491     p.creator.name,
 492     community_url,
 493     p.community.name,
 494     p.counts.score,
 495     post_url,
 496     p.counts.comments);
 497
 498     // If its a url post, add it to the description
 499     if let Some(url) = p.post.url {
 500       let link_html = format!("<br><a href=\"{url}\">{url}</a>");
 501       description.push_str(&link_html);
 502     }
 503
 504     if let Some(body) = p.post.body {
 505       let html = markdown_to_html(&body);
 506       description.push_str(&html);
 507     }
 508
 509     i.description(description);
 510
 511     i.dublin_core_ext(dc_extension.build());
 512     items.push(i.build());
 513   }
 514
 515   Ok(items)
 516 }