X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Froutes%2Fsrc%2Ffeeds.rs;h=96e718631b392b80f6abeb2ae9bde9f1dcb7c0e4;hb=c8063f3267cf2b3622f1fdc69128c6b55feefbbc;hp=402258585e194b4a50040169a214e03a245b443e;hpb=40609549d876e5b483affe7154bcffe5e6cf7a70;p=lemmy.git

diff --git a/crates/routes/src/feeds.rs b/crates/routes/src/feeds.rs
index 40225858..96e71863 100644
--- a/crates/routes/src/feeds.rs
+++ b/crates/routes/src/feeds.rs
@@ -1,26 +1,31 @@
-use actix_web::{error::ErrorBadRequest, *};
+use actix_web::{error::ErrorBadRequest, web, Error, HttpRequest, HttpResponse, Result};
 use anyhow::anyhow;
 use chrono::{DateTime, NaiveDateTime, Utc};
-use diesel::PgConnection;
-use lemmy_api_common::utils::blocking;
+use lemmy_api_common::context::LemmyContext;
 use lemmy_db_schema::{
   newtypes::LocalUserId,
   source::{community::Community, local_user::LocalUser, person::Person},
   traits::{ApubActor, Crud},
+  utils::DbPool,
+  CommentSortType,
   ListingType,
   SortType,
 };
 use lemmy_db_views::{
-  comment_view::CommentQueryBuilder,
-  post_view::PostQueryBuilder,
-  structs::{CommentView, PostView, SiteView},
+  post_view::PostQuery,
+  structs::{LocalUserView, PostView, SiteView},
 };
 use lemmy_db_views_actor::{
-  person_mention_view::PersonMentionQueryBuilder,
-  structs::PersonMentionView,
+  comment_reply_view::CommentReplyQuery,
+  person_mention_view::PersonMentionQuery,
+  structs::{CommentReplyView, PersonMentionView},
+};
+use lemmy_utils::{
+  cache_header::cache_1hour,
+  claims::Claims,
+  error::LemmyError,
+  utils::markdown::markdown_to_html,
 };
-use lemmy_utils::{claims::Claims, error::LemmyError, utils::markdown_to_html};
-use lemmy_websocket::LemmyContext;
 use once_cell::sync::Lazy;
 use rss::{
   extension::dublincore::DublinCoreExtensionBuilder,
@@ -31,13 +36,30 @@ use rss::{
 };
 use serde::Deserialize;
 use std::{collections::BTreeMap, str::FromStr};
-use strum::ParseError;
 
 const RSS_FETCH_LIMIT: i64 = 20;
 
 #[derive(Deserialize)]
 struct Params {
   sort: Option<String>,
+  limit: Option<i64>,
+  page: Option<i64>,
+}
+
+impl Params {
+  fn sort_type(&self) -> Result<SortType, Error> {
+    let sort_query = self
+      .sort
+      .clone()
+      .unwrap_or_else(|| SortType::Hot.to_string());
+    SortType::from_str(&sort_query).map_err(ErrorBadRequest)
+  }
+  fn get_limit(&self) -> i64 {
+    self.limit.unwrap_or(RSS_FETCH_LIMIT)
+  }
+  fn get_page(&self) -> i64 {
+    self.page.unwrap_or(1)
+  }
 }
 
 enum RequestType {
@@ -48,10 +70,15 @@ enum RequestType {
 }
 
 pub fn config(cfg: &mut web::ServiceConfig) {
-  cfg
-    .route("/feeds/{type}/{name}.xml", web::get().to(get_feed))
-    .route("/feeds/all.xml", web::get().to(get_all_feed))
-    .route("/feeds/local.xml", web::get().to(get_local_feed));
+  cfg.service(
+    web::scope("/feeds")
+      .route("/{type}/{name}.xml", web::get().to(get_feed))
+      .route("/all.xml", web::get().to(get_all_feed).wrap(cache_1hour()))
+      .route(
+        "/local.xml",
+        web::get().to(get_local_feed).wrap(cache_1hour()),
+      ),
+  );
 }
 
 static RSS_NAMESPACE: Lazy<BTreeMap<String, String>> = Lazy::new(|| {
@@ -68,8 +95,16 @@ async fn get_all_feed(
   info: web::Query<Params>,
   context: web::Data<LemmyContext>,
 ) -> Result<HttpResponse, Error> {
-  let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
-  Ok(get_feed_data(&context, ListingType::All, sort_type).await?)
+  Ok(
+    get_feed_data(
+      &context,
+      ListingType::All,
+      info.sort_type()?,
+      info.get_limit(),
+      info.get_page(),
+    )
+    .await?,
+  )
 }
 
 #[tracing::instrument(skip_all)]
@@ -77,8 +112,16 @@ async fn get_local_feed(
   info: web::Query<Params>,
   context: web::Data<LemmyContext>,
 ) -> Result<HttpResponse, Error> {
-  let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
-  Ok(get_feed_data(&context, ListingType::Local, sort_type).await?)
+  Ok(
+    get_feed_data(
+      &context,
+      ListingType::Local,
+      info.sort_type()?,
+      info.get_limit(),
+      info.get_page(),
+    )
+    .await?,
+  )
 }
 
 #[tracing::instrument(skip_all)]
@@ -86,23 +129,26 @@ async fn get_feed_data(
   context: &LemmyContext,
   listing_type: ListingType,
   sort_type: SortType,
+  limit: i64,
+  page: i64,
 ) -> Result<HttpResponse, LemmyError> {
-  let site_view = blocking(context.pool(), SiteView::read_local).await??;
-
-  let posts = blocking(context.pool(), move |conn| {
-    PostQueryBuilder::create(conn)
-      .listing_type(listing_type)
-      .sort(sort_type)
-      .limit(RSS_FETCH_LIMIT)
-      .list()
-  })
-  .await??;
+  let site_view = SiteView::read_local(&mut context.pool()).await?;
+
+  let posts = PostQuery {
+    listing_type: (Some(listing_type)),
+    sort: (Some(sort_type)),
+    limit: (Some(limit)),
+    page: (Some(page)),
+    ..Default::default()
+  }
+  .list(&mut context.pool())
+  .await?;
 
   let items = create_post_items(posts, &context.settings().get_protocol_and_hostname())?;
 
   let mut channel_builder = ChannelBuilder::default();
   channel_builder
-    .namespaces(RSS_NAMESPACE.to_owned())
+    .namespaces(RSS_NAMESPACE.clone())
     .title(&format!("{} - {}", site_view.site.name, listing_type))
     .link(context.settings().get_protocol_and_hostname())
     .items(items);
@@ -125,8 +171,6 @@ async fn get_feed(
   info: web::Query<Params>,
   context: web::Data<LemmyContext>,
 ) -> Result<HttpResponse, Error> {
-  let sort_type = get_sort_type(info).map_err(ErrorBadRequest)?;
-
   let req_type: String = req.match_info().get("type").unwrap_or("none").parse()?;
   let param: String = req.match_info().get("name").unwrap_or("none").parse()?;
 
@@ -138,22 +182,54 @@ async fn get_feed(
     _ => return Err(ErrorBadRequest(LemmyError::from(anyhow!("wrong_type")))),
   };
 
-  let jwt_secret = context.secret().jwt_secret.to_owned();
+  let jwt_secret = context.secret().jwt_secret.clone();
   let protocol_and_hostname = context.settings().get_protocol_and_hostname();
 
-  let builder = blocking(context.pool(), move |conn| match request_type {
-    RequestType::User => get_feed_user(conn, &sort_type, &param, &protocol_and_hostname),
-    RequestType::Community => get_feed_community(conn, &sort_type, &param, &protocol_and_hostname),
-    RequestType::Front => get_feed_front(
-      conn,
-      &jwt_secret,
-      &sort_type,
-      &param,
-      &protocol_and_hostname,
-    ),
-    RequestType::Inbox => get_feed_inbox(conn, &jwt_secret, &param, &protocol_and_hostname),
-  })
-  .await?
+  let builder = match request_type {
+    RequestType::User => {
+      get_feed_user(
+        &mut context.pool(),
+        &info.sort_type()?,
+        &info.get_limit(),
+        &info.get_page(),
+        &param,
+        &protocol_and_hostname,
+      )
+      .await
+    }
+    RequestType::Community => {
+      get_feed_community(
+        &mut context.pool(),
+        &info.sort_type()?,
+        &info.get_limit(),
+        &info.get_page(),
+        &param,
+        &protocol_and_hostname,
+      )
+      .await
+    }
+    RequestType::Front => {
+      get_feed_front(
+        &mut context.pool(),
+        &jwt_secret,
+        &info.sort_type()?,
+        &info.get_limit(),
+        &info.get_page(),
+        &param,
+        &protocol_and_hostname,
+      )
+      .await
+    }
+    RequestType::Inbox => {
+      get_feed_inbox(
+        &mut context.pool(),
+        &jwt_secret,
+        &param,
+        &protocol_and_hostname,
+      )
+      .await
+    }
+  }
   .map_err(ErrorBadRequest)?;
 
   let rss = builder.build().to_string();
@@ -165,36 +241,34 @@ async fn get_feed(
   )
 }
 
-fn get_sort_type(info: web::Query<Params>) -> Result<SortType, ParseError> {
-  let sort_query = info
-    .sort
-    .to_owned()
-    .unwrap_or_else(|| SortType::Hot.to_string());
-  SortType::from_str(&sort_query)
-}
-
 #[tracing::instrument(skip_all)]
-fn get_feed_user(
-  conn: &PgConnection,
+async fn get_feed_user(
+  pool: &mut DbPool<'_>,
   sort_type: &SortType,
+  limit: &i64,
+  page: &i64,
   user_name: &str,
   protocol_and_hostname: &str,
 ) -> Result<ChannelBuilder, LemmyError> {
-  let site_view = SiteView::read_local(conn)?;
-  let person = Person::read_from_name(conn, user_name)?;
-
-  let posts = PostQueryBuilder::create(conn)
-    .listing_type(ListingType::All)
-    .sort(*sort_type)
-    .creator_id(person.id)
-    .limit(RSS_FETCH_LIMIT)
-    .list()?;
+  let site_view = SiteView::read_local(pool).await?;
+  let person = Person::read_from_name(pool, user_name, false).await?;
+
+  let posts = PostQuery {
+    listing_type: (Some(ListingType::All)),
+    sort: (Some(*sort_type)),
+    creator_id: (Some(person.id)),
+    limit: (Some(*limit)),
+    page: (Some(*page)),
+    ..Default::default()
+  }
+  .list(pool)
+  .await?;
 
   let items = create_post_items(posts, protocol_and_hostname)?;
 
   let mut channel_builder = ChannelBuilder::default();
   channel_builder
-    .namespaces(RSS_NAMESPACE.to_owned())
+    .namespaces(RSS_NAMESPACE.clone())
     .title(&format!("{} - {}", site_view.site.name, person.name))
     .link(person.actor_id.to_string())
     .items(items);
@@ -203,27 +277,32 @@ fn get_feed_user(
 }
 
 #[tracing::instrument(skip_all)]
-fn get_feed_community(
-  conn: &PgConnection,
+async fn get_feed_community(
+  pool: &mut DbPool<'_>,
   sort_type: &SortType,
+  limit: &i64,
+  page: &i64,
   community_name: &str,
   protocol_and_hostname: &str,
 ) -> Result<ChannelBuilder, LemmyError> {
-  let site_view = SiteView::read_local(conn)?;
-  let community = Community::read_from_name(conn, community_name)?;
-
-  let posts = PostQueryBuilder::create(conn)
-    .listing_type(ListingType::Community)
-    .sort(*sort_type)
-    .community_id(community.id)
-    .limit(RSS_FETCH_LIMIT)
-    .list()?;
+  let site_view = SiteView::read_local(pool).await?;
+  let community = Community::read_from_name(pool, community_name, false).await?;
+
+  let posts = PostQuery {
+    sort: (Some(*sort_type)),
+    community_id: (Some(community.id)),
+    limit: (Some(*limit)),
+    page: (Some(*page)),
+    ..Default::default()
+  }
+  .list(pool)
+  .await?;
 
   let items = create_post_items(posts, protocol_and_hostname)?;
 
   let mut channel_builder = ChannelBuilder::default();
   channel_builder
-    .namespaces(RSS_NAMESPACE.to_owned())
+    .namespaces(RSS_NAMESPACE.clone())
     .title(&format!("{} - {}", site_view.site.name, community.name))
     .link(community.actor_id.to_string())
     .items(items);
@@ -236,31 +315,35 @@ fn get_feed_community(
 }
 
 #[tracing::instrument(skip_all)]
-fn get_feed_front(
-  conn: &PgConnection,
+async fn get_feed_front(
+  pool: &mut DbPool<'_>,
   jwt_secret: &str,
   sort_type: &SortType,
+  limit: &i64,
+  page: &i64,
   jwt: &str,
   protocol_and_hostname: &str,
 ) -> Result<ChannelBuilder, LemmyError> {
-  let site_view = SiteView::read_local(conn)?;
+  let site_view = SiteView::read_local(pool).await?;
   let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
-  let local_user = LocalUser::read(conn, local_user_id)?;
-
-  let posts = PostQueryBuilder::create(conn)
-    .listing_type(ListingType::Subscribed)
-    .my_person_id(local_user.person_id)
-    .show_bot_accounts(local_user.show_bot_accounts)
-    .show_read_posts(local_user.show_read_posts)
-    .sort(*sort_type)
-    .limit(RSS_FETCH_LIMIT)
-    .list()?;
+  let local_user = LocalUserView::read(pool, local_user_id).await?;
+
+  let posts = PostQuery {
+    listing_type: (Some(ListingType::Subscribed)),
+    local_user: (Some(&local_user)),
+    sort: (Some(*sort_type)),
+    limit: (Some(*limit)),
+    page: (Some(*page)),
+    ..Default::default()
+  }
+  .list(pool)
+  .await?;
 
   let items = create_post_items(posts, protocol_and_hostname)?;
 
   let mut channel_builder = ChannelBuilder::default();
   channel_builder
-    .namespaces(RSS_NAMESPACE.to_owned())
+    .namespaces(RSS_NAMESPACE.clone())
     .title(&format!("{} - Subscribed", site_view.site.name))
     .link(protocol_and_hostname)
     .items(items);
@@ -273,42 +356,49 @@ fn get_feed_front(
 }
 
 #[tracing::instrument(skip_all)]
-fn get_feed_inbox(
-  conn: &PgConnection,
+async fn get_feed_inbox(
+  pool: &mut DbPool<'_>,
   jwt_secret: &str,
   jwt: &str,
   protocol_and_hostname: &str,
 ) -> Result<ChannelBuilder, LemmyError> {
-  let site_view = SiteView::read_local(conn)?;
+  let site_view = SiteView::read_local(pool).await?;
   let local_user_id = LocalUserId(Claims::decode(jwt, jwt_secret)?.claims.sub);
-  let local_user = LocalUser::read(conn, local_user_id)?;
+  let local_user = LocalUser::read(pool, local_user_id).await?;
   let person_id = local_user.person_id;
   let show_bot_accounts = local_user.show_bot_accounts;
 
-  let sort = SortType::New;
-
-  let replies = CommentQueryBuilder::create(conn)
-    .recipient_id(person_id)
-    .my_person_id(person_id)
-    .show_bot_accounts(show_bot_accounts)
-    .sort(sort)
-    .limit(RSS_FETCH_LIMIT)
-    .list()?;
+  let sort = CommentSortType::New;
 
-  let mentions = PersonMentionQueryBuilder::create(conn)
-    .recipient_id(person_id)
-    .my_person_id(person_id)
-    .sort(sort)
-    .limit(RSS_FETCH_LIMIT)
-    .list()?;
+  let replies = CommentReplyQuery {
+    recipient_id: (Some(person_id)),
+    my_person_id: (Some(person_id)),
+    show_bot_accounts: (show_bot_accounts),
+    sort: (Some(sort)),
+    limit: (Some(RSS_FETCH_LIMIT)),
+    ..Default::default()
+  }
+  .list(pool)
+  .await?;
+
+  let mentions = PersonMentionQuery {
+    recipient_id: (Some(person_id)),
+    my_person_id: (Some(person_id)),
+    show_bot_accounts: (show_bot_accounts),
+    sort: (Some(sort)),
+    limit: (Some(RSS_FETCH_LIMIT)),
+    ..Default::default()
+  }
+  .list(pool)
+  .await?;
 
   let items = create_reply_and_mention_items(replies, mentions, protocol_and_hostname)?;
 
   let mut channel_builder = ChannelBuilder::default();
   channel_builder
-    .namespaces(RSS_NAMESPACE.to_owned())
+    .namespaces(RSS_NAMESPACE.clone())
     .title(&format!("{} - Inbox", site_view.site.name))
-    .link(format!("{}/inbox", protocol_and_hostname,))
+    .link(format!("{protocol_and_hostname}/inbox",))
     .items(items);
 
   if let Some(site_desc) = site_view.site.description {
@@ -320,17 +410,14 @@ fn get_feed_inbox(
 
 #[tracing::instrument(skip_all)]
 fn create_reply_and_mention_items(
-  replies: Vec<CommentView>,
+  replies: Vec<CommentReplyView>,
   mentions: Vec<PersonMentionView>,
   protocol_and_hostname: &str,
 ) -> Result<Vec<Item>, LemmyError> {
   let mut reply_items: Vec<Item> = replies
     .iter()
     .map(|r| {
-      let reply_url = format!(
-        "{}/post/{}/comment/{}",
-        protocol_and_hostname, r.post.id, r.comment.id
-      );
+      let reply_url = format!("{}/comment/{}", protocol_and_hostname, r.comment.id);
       build_item(
         &r.creator.name,
         &r.comment.published,
@@ -344,10 +431,7 @@ fn create_reply_and_mention_items(
   let mut mention_items: Vec<Item> = mentions
     .iter()
     .map(|m| {
-      let mention_url = format!(
-        "{}/post/{}/comment/{}",
-        protocol_and_hostname, m.post.id, m.comment.id
-      );
+      let mention_url = format!("{}/comment/{}", protocol_and_hostname, m.comment.id);
       build_item(
         &m.creator.name,
         &m.comment.published,
@@ -371,11 +455,10 @@ fn build_item(
   protocol_and_hostname: &str,
 ) -> Result<Item, LemmyError> {
   let mut i = ItemBuilder::default();
-  i.title(format!("Reply from {}", creator_name));
-  let author_url = format!("{}/u/{}", protocol_and_hostname, creator_name);
+  i.title(format!("Reply from {creator_name}"));
+  let author_url = format!("{protocol_and_hostname}/u/{creator_name}");
   i.author(format!(
-    "/u/{} <a href=\"{}\">(link)</a>",
-    creator_name, author_url
+    "/u/{creator_name} <a href=\"{author_url}\">(link)</a>"
   ));
   let dt = DateTime::<Utc>::from_utc(*published, Utc);
   i.pub_date(dt.to_rfc2822());
@@ -408,8 +491,7 @@ fn create_post_items(
     i.pub_date(dt.to_rfc2822());
 
     let post_url = format!("{}/post/{}", protocol_and_hostname, p.post.id);
-    i.link(post_url.to_owned());
-    i.comments(post_url.to_owned());
+    i.comments(post_url.clone());
     let guid = GuidBuilder::default()
       .permalink(true)
       .value(&post_url)
@@ -430,8 +512,11 @@ fn create_post_items(
 
     // If its a url post, add it to the description
     if let Some(url) = p.post.url {
-      let link_html = format!("<br><a href=\"{url}\">{url}</a>", url = url);
+      let link_html = format!("<br><a href=\"{url}\">{url}</a>");
       description.push_str(&link_html);
+      i.link(url.to_string());
+    } else {
+      i.link(post_url.clone());
     }
 
     if let Some(body) = p.post.body {