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_, user::User},
   8   ListingType,
   9   SortType,
  10 };
  11 use lemmy_db_schema::source::{community::Community, user::User_};
  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::user_mention_view::{UserMentionQueryBuilder, UserMentionView};
  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 user = User_::find_by_username(&conn, &user_name)?;
 171   let user_url = user.get_profile_url(&Settings::get().hostname());
 172
 173   let posts = PostQueryBuilder::create(&conn)
 174     .listing_type(&ListingType::All)
 175     .sort(sort_type)
 176     .creator_id(user.id)
 177     .list()?;
 178
 179   let items = create_post_items(posts)?;
 180
 181   let mut channel_builder = ChannelBuilder::default();
 182   channel_builder
 183     .namespaces(RSS_NAMESPACE.to_owned())
 184     .title(&format!("{} - {}", site_view.site.name, user.name))
 185     .link(user_url)
 186     .items(items);
 187
 188   Ok(channel_builder)
 189 }
 190
 191 fn get_feed_community(
 192   conn: &PgConnection,
 193   sort_type: &SortType,
 194   community_name: String,
 195 ) -> Result<ChannelBuilder, LemmyError> {
 196   let site_view = SiteView::read(&conn)?;
 197   let community = Community::read_from_name(&conn, &community_name)?;
 198
 199   let posts = PostQueryBuilder::create(&conn)
 200     .listing_type(&ListingType::All)
 201     .sort(sort_type)
 202     .community_id(community.id)
 203     .list()?;
 204
 205   let items = create_post_items(posts)?;
 206
 207   let mut channel_builder = ChannelBuilder::default();
 208   channel_builder
 209     .namespaces(RSS_NAMESPACE.to_owned())
 210     .title(&format!("{} - {}", site_view.site.name, community.name))
 211     .link(community.actor_id.to_string())
 212     .items(items);
 213
 214   if let Some(community_desc) = community.description {
 215     channel_builder.description(&community_desc);
 216   }
 217
 218   Ok(channel_builder)
 219 }
 220
 221 fn get_feed_front(
 222   conn: &PgConnection,
 223   sort_type: &SortType,
 224   jwt: String,
 225 ) -> Result<ChannelBuilder, LemmyError> {
 226   let site_view = SiteView::read(&conn)?;
 227   let user_id = Claims::decode(&jwt)?.claims.id;
 228
 229   let posts = PostQueryBuilder::create(&conn)
 230     .listing_type(&ListingType::Subscribed)
 231     .my_user_id(user_id)
 232     .sort(sort_type)
 233     .list()?;
 234
 235   let items = create_post_items(posts)?;
 236
 237   let mut channel_builder = ChannelBuilder::default();
 238   channel_builder
 239     .namespaces(RSS_NAMESPACE.to_owned())
 240     .title(&format!("{} - Subscribed", site_view.site.name))
 241     .link(Settings::get().get_protocol_and_hostname())
 242     .items(items);
 243
 244   if let Some(site_desc) = site_view.site.description {
 245     channel_builder.description(&site_desc);
 246   }
 247
 248   Ok(channel_builder)
 249 }
 250
 251 fn get_feed_inbox(conn: &PgConnection, jwt: String) -> Result<ChannelBuilder, LemmyError> {
 252   let site_view = SiteView::read(&conn)?;
 253   let user_id = Claims::decode(&jwt)?.claims.id;
 254
 255   let sort = SortType::New;
 256
 257   let replies = CommentQueryBuilder::create(&conn)
 258     .recipient_id(user_id)
 259     .my_user_id(user_id)
 260     .sort(&sort)
 261     .list()?;
 262
 263   let mentions = UserMentionQueryBuilder::create(&conn)
 264     .recipient_id(user_id)
 265     .my_user_id(user_id)
 266     .sort(&sort)
 267     .list()?;
 268
 269   let items = create_reply_and_mention_items(replies, mentions)?;
 270
 271   let mut channel_builder = ChannelBuilder::default();
 272   channel_builder
 273     .namespaces(RSS_NAMESPACE.to_owned())
 274     .title(&format!("{} - Inbox", site_view.site.name))
 275     .link(format!(
 276       "{}/inbox",
 277       Settings::get().get_protocol_and_hostname()
 278     ))
 279     .items(items);
 280
 281   if let Some(site_desc) = site_view.site.description {
 282     channel_builder.description(&site_desc);
 283   }
 284
 285   Ok(channel_builder)
 286 }
 287
 288 fn create_reply_and_mention_items(
 289   replies: Vec<CommentView>,
 290   mentions: Vec<UserMentionView>,
 291 ) -> Result<Vec<Item>, LemmyError> {
 292   let mut reply_items: Vec<Item> = replies
 293     .iter()
 294     .map(|r| {
 295       let reply_url = format!(
 296         "{}/post/{}/comment/{}",
 297         Settings::get().get_protocol_and_hostname(),
 298         r.post.id,
 299         r.comment.id
 300       );
 301       build_item(
 302         &r.creator.name,
 303         &r.comment.published,
 304         &reply_url,
 305         &r.comment.content,
 306       )
 307     })
 308     .collect::<Result<Vec<Item>, LemmyError>>()?;
 309
 310   let mut mention_items: Vec<Item> = mentions
 311     .iter()
 312     .map(|m| {
 313       let mention_url = format!(
 314         "{}/post/{}/comment/{}",
 315         Settings::get().get_protocol_and_hostname(),
 316         m.post.id,
 317         m.comment.id
 318       );
 319       build_item(
 320         &m.creator.name,
 321         &m.comment.published,
 322         &mention_url,
 323         &m.comment.content,
 324       )
 325     })
 326     .collect::<Result<Vec<Item>, LemmyError>>()?;
 327
 328   reply_items.append(&mut mention_items);
 329   Ok(reply_items)
 330 }
 331
 332 fn build_item(
 333   creator_name: &str,
 334   published: &NaiveDateTime,
 335   url: &str,
 336   content: &str,
 337 ) -> Result<Item, LemmyError> {
 338   let mut i = ItemBuilder::default();
 339   i.title(format!("Reply from {}", creator_name));
 340   let author_url = format!(
 341     "{}/u/{}",
 342     Settings::get().get_protocol_and_hostname(),
 343     creator_name
 344   );
 345   i.author(format!(
 346     "/u/{} <a href=\"{}\">(link)</a>",
 347     creator_name, author_url
 348   ));
 349   let dt = DateTime::<Utc>::from_utc(*published, Utc);
 350   i.pub_date(dt.to_rfc2822());
 351   i.comments(url.to_owned());
 352   let guid = GuidBuilder::default()
 353     .permalink(true)
 354     .value(url)
 355     .build()
 356     .map_err(|e| anyhow!(e))?;
 357   i.guid(guid);
 358   i.link(url.to_owned());
 359   // TODO add images
 360   let html = markdown_to_html(&content.to_string());
 361   i.description(html);
 362   Ok(i.build().map_err(|e| anyhow!(e))?)
 363 }
 364
 365 fn create_post_items(posts: Vec<PostView>) -> Result<Vec<Item>, LemmyError> {
 366   let mut items: Vec<Item> = Vec::new();
 367
 368   for p in posts {
 369     let mut i = ItemBuilder::default();
 370     let mut dc_extension = DublinCoreExtensionBuilder::default();
 371
 372     i.title(p.post.name);
 373
 374     dc_extension.creators(vec![p.creator.actor_id.to_string()]);
 375
 376     let dt = DateTime::<Utc>::from_utc(p.post.published, Utc);
 377     i.pub_date(dt.to_rfc2822());
 378
 379     let post_url = format!(
 380       "{}/post/{}",
 381       Settings::get().get_protocol_and_hostname(),
 382       p.post.id
 383     );
 384     i.link(post_url.to_owned());
 385     i.comments(post_url.to_owned());
 386     let guid = GuidBuilder::default()
 387       .permalink(true)
 388       .value(&post_url)
 389       .build()
 390       .map_err(|e| anyhow!(e))?;
 391     i.guid(guid);
 392
 393     let community_url = format!(
 394       "{}/c/{}",
 395       Settings::get().get_protocol_and_hostname(),
 396       p.community.name
 397     );
 398
 399     // TODO add images
 400     let mut description = format!("submitted by <a href=\"{}\">{}</a> to <a href=\"{}\">{}</a><br>{} points | <a href=\"{}\">{} comments</a>",
 401     p.creator.actor_id,
 402     p.creator.name,
 403     community_url,
 404     p.community.name,
 405     p.counts.score,
 406     post_url,
 407     p.counts.comments);
 408
 409     // If its a url post, add it to the description
 410     if let Some(url) = p.post.url {
 411       let link_html = format!("<br><a href=\"{url}\">{url}</a>", url = url);
 412       description.push_str(&link_html);
 413     }
 414
 415     if let Some(body) = p.post.body {
 416       let html = markdown_to_html(&body);
 417       description.push_str(&html);
 418     }
 419
 420     i.description(description);
 421
 422     i.dublin_core_ext(dc_extension.build().map_err(|e| anyhow!(e))?);
 423     items.push(i.build().map_err(|e| anyhow!(e))?);
 424   }
 425
 426   Ok(items)
 427 }