crates/routes/src/feeds.rs

   1 use actix_web::{error::ErrorBadRequest, *};
   2 use anyhow::anyhow;
   3 use chrono::{DateTime, NaiveDateTime, Utc};
   4 use diesel::PgConnection;
   5 use lemmy_api_common::utils::blocking;
   6 use lemmy_db_schema::{
   7   newtypes::LocalUserId,
   8   source::{community::Community, local_user::LocalUser, person::Person},
   9   traits::{ApubActor, Crud},
  10   ListingType,
  11   SortType,
  12 };
  13 use lemmy_db_views::{
  14   comment_view::CommentQueryBuilder,
  15   post_view::PostQueryBuilder,
  16   structs::{CommentView, PostView, SiteView},
  17 };
  18 use lemmy_db_views_actor::{
  19   person_mention_view::PersonMentionQueryBuilder,
  20   structs::PersonMentionView,
  21 };
  22 use lemmy_utils::{claims::Claims, error::LemmyError, utils::markdown_to_html};
  23 use lemmy_websocket::LemmyContext;
  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 use strum::ParseError;
  35
  36 const RSS_FETCH_LIMIT: i64 = 20;
  37
  38 #[derive(Deserialize)]
  39 struct Params {
  40   sort: Option<String>,
  41 }
  42
  43 enum RequestType {
  44   Community,
  45   User,
  46   Front,
  47   Inbox,
  48 }
  49
  50 pub fn config(cfg: &mut web::ServiceConfig) {
  51   cfg
  52     .route("/feeds/{type}/{name}.xml", web::get().to(get_feed))
  53     .route("/feeds/all.xml", web::get().to(get_all_feed))
  54     .route("/feeds/local.xml", web::get().to(get_local_feed));
  55 }
  56
  57 static RSS_NAMESPACE: Lazy<BTreeMap<String, String>> = Lazy::new(|| {
  58   let mut h = BTreeMap::new();
  59   h.insert(
  60     "dc".to_string(),
  61     rss::extension::dublincore::NAMESPACE.to_string(),
  62   );
  63   h
  64 });
  65
  66 #[tracing::instrument(skip_all)]
  67 async fn get_all_feed(
  68   info: web::Query<Params>,
  69   context: web::Data<LemmyContext>,
  70 ) -> Result<HttpResponse, Error> {
  71   let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
  72   Ok(get_feed_data(&context, ListingType::All, sort_type).await?)
  73 }
  74
  75 #[tracing::instrument(skip_all)]
  76 async fn get_local_feed(
  77   info: web::Query<Params>,
  78   context: web::Data<LemmyContext>,
  79 ) -> Result<HttpResponse, Error> {
  80   let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
  81   Ok(get_feed_data(&context, ListingType::Local, sort_type).await?)
  82 }
  83
  84 #[tracing::instrument(skip_all)]
  85 async fn get_feed_data(
  86   context: &LemmyContext,
  87   listing_type: ListingType,
  88   sort_type: SortType,
  89 ) -> Result<HttpResponse, LemmyError> {
  90   let site_view = blocking(context.pool(), SiteView::read_local).await??;
  91
  92   let posts = blocking(context.pool(), move |conn| {
  93     PostQueryBuilder::create(conn)
  94       .listing_type(listing_type)
  95       .sort(sort_type)
  96       .limit(RSS_FETCH_LIMIT)
  97       .list()
  98   })
  99   .await??;
 100
 101   let items = create_post_items(posts, &context.settings().get_protocol_and_hostname())?;
 102
 103   let mut channel_builder = ChannelBuilder::default();
 104   channel_builder
 105     .namespaces(RSS_NAMESPACE.to_owned())
 106     .title(&format!("{} - {}", site_view.site.name, listing_type))
 107     .link(context.settings().get_protocol_and_hostname())
 108     .items(items);
 109
 110   if let Some(site_desc) = site_view.site.description {
 111     channel_builder.description(&site_desc);
 112   }
 113
 114   let rss = channel_builder.build().to_string();
 115   Ok(
 116     HttpResponse::Ok()
 117       .content_type("application/rss+xml")
 118       .body(rss),
 119   )
 120 }
 121
 122 #[tracing::instrument(skip_all)]
 123 async fn get_feed(
 124   req: HttpRequest,
 125   info: web::Query<Params>,
 126   context: web::Data<LemmyContext>,
 127 ) -> Result<HttpResponse, Error> {
 128   let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
 129
 130   let req_type: String = req.match_info().get("type").unwrap_or("none").parse()?;
 131   let param: String = req.match_info().get("name").unwrap_or("none").parse()?;
 132
 133   let request_type = match req_type.as_str() {
 134     "u" => RequestType::User,
 135     "c" => RequestType::Community,
 136     "front" => RequestType::Front,
 137     "inbox" => RequestType::Inbox,
 138     _ => return Err(ErrorBadRequest(LemmyError::from(anyhow!("wrong_type")))),
 139   };
 140
 141   let jwt_secret = context.secret().jwt_secret.to_owned();
 142   let protocol_and_hostname = context.settings().get_protocol_and_hostname();
 143
 144   let builder = blocking(context.pool(), move |conn| match request_type {
 145     RequestType::User => get_feed_user(conn, &sort_type, &param, &protocol_and_hostname),
 146     RequestType::Community => get_feed_community(conn, &sort_type, &param, &protocol_and_hostname),
 147     RequestType::Front => get_feed_front(
 148       conn,
 149       &jwt_secret,
 150       &sort_type,
 151       &param,
 152       &protocol_and_hostname,
 153     ),
 154     RequestType::Inbox => get_feed_inbox(conn, &jwt_secret, &param, &protocol_and_hostname),
 155   })
 156   .await?
 157   .map_err(ErrorBadRequest)?;
 158
 159   let rss = builder.build().to_string();
 160
 161   Ok(
 162     HttpResponse::Ok()
 163       .content_type("application/rss+xml")
 164       .body(rss),
 165   )
 166 }
 167
 168 fn get_sort_type(info: web::Query<Params>) -> Result<SortType, ParseError> {
 169   let sort_query = info
 170     .sort
 171     .to_owned()
 172     .unwrap_or_else(|| SortType::Hot.to_string());
 173   SortType::from_str(&sort_query)
 174 }
 175
 176 #[tracing::instrument(skip_all)]
 177 fn get_feed_user(
 178   conn: &PgConnection,
 179   sort_type: &SortType,
 180   user_name: &str,
 181   protocol_and_hostname: &str,
 182 ) -> Result<ChannelBuilder, LemmyError> {
 183   let site_view = SiteView::read_local(conn)?;
 184   let person = Person::read_from_name(conn, user_name, false)?;
 185
 186   let posts = PostQueryBuilder::create(conn)
 187     .listing_type(ListingType::All)
 188     .sort(*sort_type)
 189     .creator_id(person.id)
 190     .limit(RSS_FETCH_LIMIT)
 191     .list()?;
 192
 193   let items = create_post_items(posts, protocol_and_hostname)?;
 194
 195   let mut channel_builder = ChannelBuilder::default();
 196   channel_builder
 197     .namespaces(RSS_NAMESPACE.to_owned())
 198     .title(&format!("{} - {}", site_view.site.name, person.name))
 199     .link(person.actor_id.to_string())
 200     .items(items);
 201
 202   Ok(channel_builder)
 203 }
 204
 205 #[tracing::instrument(skip_all)]
 206 fn get_feed_community(
 207   conn: &PgConnection,
 208   sort_type: &SortType,
 209   community_name: &str,
 210   protocol_and_hostname: &str,
 211 ) -> Result<ChannelBuilder, LemmyError> {
 212   let site_view = SiteView::read_local(conn)?;
 213   let community = Community::read_from_name(conn, community_name, false)?;
 214
 215   let posts = PostQueryBuilder::create(conn)
 216     .sort(*sort_type)
 217     .community_id(community.id)
 218     .limit(RSS_FETCH_LIMIT)
 219     .list()?;
 220
 221   let items = create_post_items(posts, protocol_and_hostname)?;
 222
 223   let mut channel_builder = ChannelBuilder::default();
 224   channel_builder
 225     .namespaces(RSS_NAMESPACE.to_owned())
 226     .title(&format!("{} - {}", site_view.site.name, community.name))
 227     .link(community.actor_id.to_string())
 228     .items(items);
 229
 230   if let Some(community_desc) = community.description {
 231     channel_builder.description(&community_desc);
 232   }
 233
 234   Ok(channel_builder)
 235 }
 236
 237 #[tracing::instrument(skip_all)]
 238 fn get_feed_front(
 239   conn: &PgConnection,
 240   jwt_secret: &str,
 241   sort_type: &SortType,
 242   jwt: &str,
 243   protocol_and_hostname: &str,
 244 ) -> Result<ChannelBuilder, LemmyError> {
 245   let site_view = SiteView::read_local(conn)?;
 246   let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
 247   let local_user = LocalUser::read(conn, local_user_id)?;
 248
 249   let posts = PostQueryBuilder::create(conn)
 250     .listing_type(ListingType::Subscribed)
 251     .my_person_id(local_user.person_id)
 252     .show_bot_accounts(local_user.show_bot_accounts)
 253     .show_read_posts(local_user.show_read_posts)
 254     .sort(*sort_type)
 255     .limit(RSS_FETCH_LIMIT)
 256     .list()?;
 257
 258   let items = create_post_items(posts, protocol_and_hostname)?;
 259
 260   let mut channel_builder = ChannelBuilder::default();
 261   channel_builder
 262     .namespaces(RSS_NAMESPACE.to_owned())
 263     .title(&format!("{} - Subscribed", site_view.site.name))
 264     .link(protocol_and_hostname)
 265     .items(items);
 266
 267   if let Some(site_desc) = site_view.site.description {
 268     channel_builder.description(&site_desc);
 269   }
 270
 271   Ok(channel_builder)
 272 }
 273
 274 #[tracing::instrument(skip_all)]
 275 fn get_feed_inbox(
 276   conn: &PgConnection,
 277   jwt_secret: &str,
 278   jwt: &str,
 279   protocol_and_hostname: &str,
 280 ) -> Result<ChannelBuilder, LemmyError> {
 281   let site_view = SiteView::read_local(conn)?;
 282   let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
 283   let local_user = LocalUser::read(conn, local_user_id)?;
 284   let person_id = local_user.person_id;
 285   let show_bot_accounts = local_user.show_bot_accounts;
 286
 287   let sort = SortType::New;
 288
 289   let replies = CommentQueryBuilder::create(conn)
 290     .recipient_id(person_id)
 291     .my_person_id(person_id)
 292     .show_bot_accounts(show_bot_accounts)
 293     .sort(sort)
 294     .limit(RSS_FETCH_LIMIT)
 295     .list()?;
 296
 297   let mentions = PersonMentionQueryBuilder::create(conn)
 298     .recipient_id(person_id)
 299     .my_person_id(person_id)
 300     .sort(sort)
 301     .limit(RSS_FETCH_LIMIT)
 302     .list()?;
 303
 304   let items = create_reply_and_mention_items(replies, mentions, protocol_and_hostname)?;
 305
 306   let mut channel_builder = ChannelBuilder::default();
 307   channel_builder
 308     .namespaces(RSS_NAMESPACE.to_owned())
 309     .title(&format!("{} - Inbox", site_view.site.name))
 310     .link(format!("{}/inbox", protocol_and_hostname,))
 311     .items(items);
 312
 313   if let Some(site_desc) = site_view.site.description {
 314     channel_builder.description(&site_desc);
 315   }
 316
 317   Ok(channel_builder)
 318 }
 319
 320 #[tracing::instrument(skip_all)]
 321 fn create_reply_and_mention_items(
 322   replies: Vec<CommentView>,
 323   mentions: Vec<PersonMentionView>,
 324   protocol_and_hostname: &str,
 325 ) -> Result<Vec<Item>, LemmyError> {
 326   let mut reply_items: Vec<Item> = replies
 327     .iter()
 328     .map(|r| {
 329       let reply_url = format!(
 330         "{}/post/{}/comment/{}",
 331         protocol_and_hostname, r.post.id, r.comment.id
 332       );
 333       build_item(
 334         &r.creator.name,
 335         &r.comment.published,
 336         &reply_url,
 337         &r.comment.content,
 338         protocol_and_hostname,
 339       )
 340     })
 341     .collect::<Result<Vec<Item>, LemmyError>>()?;
 342
 343   let mut mention_items: Vec<Item> = mentions
 344     .iter()
 345     .map(|m| {
 346       let mention_url = format!(
 347         "{}/post/{}/comment/{}",
 348         protocol_and_hostname, m.post.id, m.comment.id
 349       );
 350       build_item(
 351         &m.creator.name,
 352         &m.comment.published,
 353         &mention_url,
 354         &m.comment.content,
 355         protocol_and_hostname,
 356       )
 357     })
 358     .collect::<Result<Vec<Item>, LemmyError>>()?;
 359
 360   reply_items.append(&mut mention_items);
 361   Ok(reply_items)
 362 }
 363
 364 #[tracing::instrument(skip_all)]
 365 fn build_item(
 366   creator_name: &str,
 367   published: &NaiveDateTime,
 368   url: &str,
 369   content: &str,
 370   protocol_and_hostname: &str,
 371 ) -> Result<Item, LemmyError> {
 372   let mut i = ItemBuilder::default();
 373   i.title(format!("Reply from {}", creator_name));
 374   let author_url = format!("{}/u/{}", protocol_and_hostname, creator_name);
 375   i.author(format!(
 376     "/u/{} <a href=\"{}\">(link)</a>",
 377     creator_name, author_url
 378   ));
 379   let dt = DateTime::<Utc>::from_utc(*published, Utc);
 380   i.pub_date(dt.to_rfc2822());
 381   i.comments(url.to_owned());
 382   let guid = GuidBuilder::default().permalink(true).value(url).build();
 383   i.guid(guid);
 384   i.link(url.to_owned());
 385   // TODO add images
 386   let html = markdown_to_html(content);
 387   i.description(html);
 388   Ok(i.build())
 389 }
 390
 391 #[tracing::instrument(skip_all)]
 392 fn create_post_items(
 393   posts: Vec<PostView>,
 394   protocol_and_hostname: &str,
 395 ) -> Result<Vec<Item>, LemmyError> {
 396   let mut items: Vec<Item> = Vec::new();
 397
 398   for p in posts {
 399     let mut i = ItemBuilder::default();
 400     let mut dc_extension = DublinCoreExtensionBuilder::default();
 401
 402     i.title(p.post.name);
 403
 404     dc_extension.creators(vec![p.creator.actor_id.to_string()]);
 405
 406     let dt = DateTime::<Utc>::from_utc(p.post.published, Utc);
 407     i.pub_date(dt.to_rfc2822());
 408
 409     let post_url = format!("{}/post/{}", protocol_and_hostname, p.post.id);
 410     i.link(post_url.to_owned());
 411     i.comments(post_url.to_owned());
 412     let guid = GuidBuilder::default()
 413       .permalink(true)
 414       .value(&post_url)
 415       .build();
 416     i.guid(guid);
 417
 418     let community_url = format!("{}/c/{}", protocol_and_hostname, p.community.name);
 419
 420     // TODO add images
 421     let mut description = format!("submitted by <a href=\"{}\">{}</a> to <a href=\"{}\">{}</a><br>{} points | <a href=\"{}\">{} comments</a>",
 422     p.creator.actor_id,
 423     p.creator.name,
 424     community_url,
 425     p.community.name,
 426     p.counts.score,
 427     post_url,
 428     p.counts.comments);
 429
 430     // If its a url post, add it to the description
 431     if let Some(url) = p.post.url {
 432       let link_html = format!("<br><a href=\"{url}\">{url}</a>", url = url);
 433       description.push_str(&link_html);
 434     }
 435
 436     if let Some(body) = p.post.body {
 437       let html = markdown_to_html(&body);
 438       description.push_str(&html);
 439     }
 440
 441     i.description(description);
 442
 443     i.dublin_core_ext(dc_extension.build());
 444     items.push(i.build());
 445   }
 446
 447   Ok(items)
 448 }