Remove rest of page limit

crates/api/src/comment/list_comment_likes.rs

@@ -4,6 +4,10 @@ use lemmy_api_common::{
   context::LemmyContext,
   utils::is_mod_or_admin,
 };
+use lemmy_db_schema::{
+  source::person::Person,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
 use lemmy_db_views::structs::{CommentView, LocalUserView, VoteView};
 use lemmy_utils::error::LemmyResult;
 
@@ -27,8 +31,24 @@ pub async fn list_comment_likes(
   )
   .await?;
 
-  let comment_likes =
-    VoteView::list_for_comment(&mut context.pool(), data.comment_id, data.page, data.limit).await?;
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(Person::from_cursor(cursor, &mut context.pool()).await?)
+  } else {
+    None
+  };
+
+  let comment_likes = VoteView::list_for_comment(
+    &mut context.pool(),
+    data.comment_id,
+    cursor_data,
+    data.page_back,
+  )
+  .await?;
+
+  let next_page = comment_likes.last().map(PageCursorBuilder::cursor);
 
-  Ok(Json(ListCommentLikesResponse { comment_likes }))
+  Ok(Json(ListCommentLikesResponse {
+    comment_likes,
+    next_page,
+  }))
 }

crates/api/src/community/pending_follows/list.rs

@@ -4,6 +4,10 @@ use lemmy_api_common::{
   context::LemmyContext,
   utils::check_community_mod_of_any_or_admin_action,
 };
+use lemmy_db_schema::{
+  source::person::Person,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
 use lemmy_db_views::structs::{CommunityFollowerView, LocalUserView};
 use lemmy_utils::error::LemmyResult;
 
@@ -15,14 +19,27 @@ pub async fn get_pending_follows_list(
   check_community_mod_of_any_or_admin_action(&local_user_view, &mut context.pool()).await?;
   let all_communities =
     data.all_communities.unwrap_or_default() && local_user_view.local_user.admin;
+
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(Person::from_cursor(cursor, &mut context.pool()).await?)
+  } else {
+    None
+  };
+
   let items = CommunityFollowerView::list_approval_required(
     &mut context.pool(),
     local_user_view.person.id,
     all_communities,
     data.pending_only.unwrap_or_default(),
-    data.page,
-    data.limit,
+    cursor_data,
+    data.page_back,
   )
   .await?;
-  Ok(Json(ListCommunityPendingFollowsResponse { items }))
+
+  let next_page = items.last().map(PageCursorBuilder::cursor);
+
+  Ok(Json(ListCommunityPendingFollowsResponse {
+    items,
+    next_page,
+  }))
 }

crates/api/src/local_user/add_admin.rs

@@ -11,7 +11,7 @@ use lemmy_db_schema::{
   },
   traits::Crud,
 };
-use lemmy_db_views::structs::{LocalUserView, PersonView};
+use lemmy_db_views::{person::person_view::PersonQuery, structs::LocalUserView};
 use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
 
 pub async fn add_admin(
@@ -57,7 +57,12 @@ pub async fn add_admin(
 
   ModAdd::create(&mut context.pool(), &form).await?;
 
-  let admins = PersonView::admins(&mut context.pool()).await?;
+  let admins = PersonQuery {
+    admins_only: Some(true),
+    ..Default::default()
+  }
+  .list(&mut context.pool())
+  .await?;
 
   Ok(Json(AddAdminResponse { admins }))
 }

crates/api/src/local_user/list_banned.rs

@@ -1,16 +1,39 @@
 use actix_web::web::{Data, Json};
-use lemmy_api_common::{context::LemmyContext, person::BannedPersonsResponse, utils::is_admin};
-use lemmy_db_views::structs::{LocalUserView, PersonView};
+use lemmy_api_common::{
+  context::LemmyContext,
+  person::{BannedPersonsResponse, ListBannedPersons},
+  utils::is_admin,
+};
+use lemmy_db_schema::{
+  source::person::Person,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
+use lemmy_db_views::{person::person_view::PersonQuery, structs::LocalUserView};
 use lemmy_utils::error::LemmyResult;
 
 pub async fn list_banned_users(
+  data: Json<ListBannedPersons>,
   context: Data<LemmyContext>,
   local_user_view: LocalUserView,
 ) -> LemmyResult<Json<BannedPersonsResponse>> {
   // Make sure user is an admin
   is_admin(&local_user_view)?;
 
-  let banned = PersonView::banned(&mut context.pool()).await?;
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(Person::from_cursor(cursor, &mut context.pool()).await?)
+  } else {
+    None
+  };
 
-  Ok(Json(BannedPersonsResponse { banned }))
+  let banned = PersonQuery {
+    banned_only: Some(true),
+    cursor_data,
+    ..Default::default()
+  }
+  .list(&mut context.pool())
+  .await?;
+
+  let next_page = banned.last().map(PageCursorBuilder::cursor);
+
+  Ok(Json(BannedPersonsResponse { banned, next_page }))
 }

crates/api/src/local_user/list_media.rs

@@ -3,6 +3,10 @@ use lemmy_api_common::{
   context::LemmyContext,
   person::{ListMedia, ListMediaResponse},
 };
+use lemmy_db_schema::{
+  source::images::LocalImage,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
 use lemmy_db_views::structs::{LocalImageView, LocalUserView};
 use lemmy_utils::error::LemmyResult;
 
@@ -11,14 +15,21 @@ pub async fn list_media(
   context: Data<LemmyContext>,
   local_user_view: LocalUserView,
 ) -> LemmyResult<Json<ListMediaResponse>> {
-  let page = data.page;
-  let limit = data.limit;
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(LocalImage::from_cursor(cursor, &mut context.pool()).await?)
+  } else {
+    None
+  };
+
   let images = LocalImageView::get_all_paged_by_local_user_id(
     &mut context.pool(),
     local_user_view.local_user.id,
-    page,
-    limit,
+    cursor_data,
+    data.page_back,
   )
   .await?;
-  Ok(Json(ListMediaResponse { images }))
+
+  let next_page = images.last().map(PageCursorBuilder::cursor);
+
+  Ok(Json(ListMediaResponse { images, next_page }))
 }

crates/api/src/local_user/list_saved.rs

@@ -5,6 +5,10 @@ use lemmy_api_common::{
   person::{ListPersonSaved, ListPersonSavedResponse},
   utils::check_private_instance,
 };
+use lemmy_db_schema::{
+  source::combined::person_saved::PersonSavedCombined,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
 use lemmy_db_views::{
   combined::person_saved_combined_view::PersonSavedCombinedQuery,
   structs::{LocalUserView, SiteView},
@@ -20,22 +24,21 @@ pub async fn list_person_saved(
 
   check_private_instance(&Some(local_user_view.clone()), &local_site.local_site)?;
 
-  // parse pagination token
-  let page_after = if let Some(pa) = &data.page_cursor {
-    Some(pa.read(&mut context.pool()).await?)
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(PersonSavedCombined::from_cursor(cursor, &mut context.pool()).await?)
   } else {
     None
   };
-  let page_back = data.page_back;
-  let type_ = data.type_;
 
   let saved = PersonSavedCombinedQuery {
-    type_,
-    page_after,
-    page_back,
+    type_: data.type_,
+    cursor_data,
+    page_back: data.page_back,
   }
   .list(&mut context.pool(), &local_user_view)
   .await?;
 
-  Ok(Json(ListPersonSavedResponse { saved }))
+  let next_page = saved.last().map(PageCursorBuilder::cursor);
+
+  Ok(Json(ListPersonSavedResponse { saved, next_page }))
 }

crates/api/src/local_user/notifications/list_inbox.rs

@@ -3,6 +3,10 @@ use lemmy_api_common::{
   context::LemmyContext,
   person::{ListInbox, ListInboxResponse},
 };
+use lemmy_db_schema::{
+  source::combined::inbox::InboxCombined,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
 use lemmy_db_views::{combined::inbox_combined_view::InboxCombinedQuery, structs::LocalUserView};
 use lemmy_utils::error::LemmyResult;
 
@@ -11,28 +15,25 @@ pub async fn list_inbox(
   context: Data<LemmyContext>,
   local_user_view: LocalUserView,
 ) -> LemmyResult<Json<ListInboxResponse>> {
-  let unread_only = data.unread_only;
-  let type_ = data.type_;
   let person_id = local_user_view.person.id;
-  let show_bot_accounts = Some(local_user_view.local_user.show_bot_accounts);
 
-  // parse pagination token
-  let page_after = if let Some(pa) = &data.page_cursor {
-    Some(pa.read(&mut context.pool()).await?)
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(InboxCombined::from_cursor(cursor, &mut context.pool()).await?)
   } else {
     None
   };
-  let page_back = data.page_back;
 
   let inbox = InboxCombinedQuery {
-    type_,
-    unread_only,
-    show_bot_accounts,
-    page_after,
-    page_back,
+    type_: data.type_,
+    unread_only: data.unread_only,
+    show_bot_accounts: Some(local_user_view.local_user.show_bot_accounts),
+    cursor_data,
+    page_back: data.page_back,
   }
   .list(&mut context.pool(), person_id)
   .await?;
 
-  Ok(Json(ListInboxResponse { inbox }))
+  let next_page = inbox.last().map(PageCursorBuilder::cursor);
+
+  Ok(Json(ListInboxResponse { inbox, next_page }))
 }

crates/api/src/post/list_post_likes.rs

@@ -4,7 +4,10 @@ use lemmy_api_common::{
   post::{ListPostLikes, ListPostLikesResponse},
   utils::is_mod_or_admin,
 };
-use lemmy_db_schema::{source::post::Post, traits::Crud};
+use lemmy_db_schema::{
+  source::{person::Person, post::Post},
+  traits::{Crud, PageCursorBuilder},
+};
 use lemmy_db_views::structs::{LocalUserView, VoteView};
 use lemmy_utils::error::LemmyResult;
 
@@ -22,8 +25,24 @@ pub async fn list_post_likes(
   )
   .await?;
 
-  let post_likes =
-    VoteView::list_for_post(&mut context.pool(), data.post_id, data.page, data.limit).await?;
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(Person::from_cursor(cursor, &mut context.pool()).await?)
+  } else {
+    None
+  };
+
+  let post_likes = VoteView::list_for_post(
+    &mut context.pool(),
+    data.post_id,
+    cursor_data,
+    data.page_back,
+  )
+  .await?;
+
+  let next_page = post_likes.last().map(PageCursorBuilder::cursor);
 
-  Ok(Json(ListPostLikesResponse { post_likes }))
+  Ok(Json(ListPostLikesResponse {
+    post_likes,
+    next_page,
+  }))
 }

crates/api/src/reports/report_combined/list.rs

@@ -4,6 +4,10 @@ use lemmy_api_common::{
   reports::combined::{ListReports, ListReportsResponse},
   utils::check_community_mod_of_any_or_admin_action,
 };
+use lemmy_db_schema::{
+  source::combined::report::ReportCombined,
+  traits::{PageCursorBuilder, PageCursorReader},
+};
 use lemmy_db_views::{combined::report_combined_view::ReportCombinedQuery, structs::LocalUserView};
 use lemmy_utils::error::LemmyResult;
 
@@ -16,25 +20,25 @@ pub async fn list_reports(
 ) -> LemmyResult<Json<ListReportsResponse>> {
   check_community_mod_of_any_or_admin_action(&local_user_view, &mut context.pool()).await?;
 
-  // parse pagination token
-  let page_after = if let Some(pa) = &data.page_cursor {
-    Some(pa.read(&mut context.pool()).await?)
+  let cursor_data = if let Some(cursor) = &data.page_cursor {
+    Some(ReportCombined::from_cursor(cursor, &mut context.pool()).await?)
   } else {
     None
   };
-  let page_back = data.page_back;
 
   let reports = ReportCombinedQuery {
     community_id: data.community_id,
     post_id: data.post_id,
     type_: data.type_,
     unresolved_only: data.unresolved_only,
-    page_after,
-    page_back,
+    cursor_data,
+    page_back: data.page_back,
     show_community_rule_violations: data.show_community_rule_violations,
   }
   .list(&mut context.pool(), &local_user_view)
   .await?;
 
-  Ok(Json(ListReportsResponse { reports }))
+  let next_page = reports.last().map(PageCursorBuilder::cursor);
+
+  Ok(Json(ListReportsResponse { reports, next_page }))
 }