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