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