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