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