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