feat: add basic pagination support for admin panel (#217)

Author: ikorason

cot-macros/src/admin.rs

@@ -101,13 +101,23 @@ impl AdminModelDeriveBuilder {
                     self
                 }
 
+                async fn get_total_object_counts(
+                    request: &#crate_ident::request::Request,
+                ) -> #crate_ident::Result<usize> {
+                    use #crate_ident::db::Model;
+                    use #crate_ident::request::RequestExt;
+
+                    Ok(Self::objects().count(request.db()).await?)
+                }
+
                 async fn get_objects(
                     request: &#crate_ident::request::Request,
+                    pagination: #crate_ident::admin::Pagination,
                 ) -> #crate_ident::Result<::std::vec::Vec<Self>> {
                     use #crate_ident::db::Model;
                     use #crate_ident::request::RequestExt;
 
-                    Ok(Self::objects().all(request.db()).await?)
+                    Ok(Self::objects().limit(pagination.limit()).offset(pagination.offset()).all(request.db()).await?)
                 }
 
                 async fn get_object_by_id(

cot/src/admin.rs

@@ -4,6 +4,7 @@
 //! registered in the application, straight from the web interface.
 
 use std::any::Any;
+use std::collections::HashMap;
 use std::marker::PhantomData;
 
 use async_trait::async_trait;
@@ -24,7 +25,7 @@ use crate::auth::{AuthRequestExt, Password};
 use crate::form::{
     Form, FormContext, FormErrorTarget, FormField, FormFieldValidationError, FormResult,
 };
-use crate::request::{Request, RequestExt};
+use crate::request::{query_pairs, Request, RequestExt};
 use crate::response::{Response, ResponseExt};
 use crate::router::Router;
 use crate::{reverse_redirect, static_files, App, Body, Method, RequestHandler, StatusCode};
@@ -135,6 +136,34 @@ async fn authenticate(request: &mut Request, login_form: LoginForm) -> cot::Resu
     }
 }
 
+/// Struct representing the pagination of objects.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Pagination {
+    limit: usize,
+    offset: usize,
+}
+
+impl Pagination {
+    fn new(limit: usize, page: usize) -> Self {
+        assert!(page > 0, "Page number must be greater than 0");
+
+        Self {
+            limit,
+            offset: (page - 1) * limit,
+        }
+    }
+
+    /// Returns the limit of objects per page.
+    pub fn limit(&self) -> usize {
+        self.limit
+    }
+
+    /// Returns the offset of objects.
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+}
+
 async fn view_model(request: Request) -> cot::Result<Response> {
     #[derive(Debug, Template)]
     #[template(path = "admin/model.html")]
@@ -144,16 +173,54 @@ async fn view_model(request: Request) -> cot::Result<Response> {
         model: &'a dyn AdminModelManager,
         #[debug("..")]
         objects: Vec<Box<dyn AdminModel>>,
+        page: usize,
+        page_size: &'a usize,
+        total_object_counts: usize,
+        total_pages: usize,
     }
 
     let model_name: String = request.path_params().parse()?;
     let manager = get_manager(&request, &model_name)?;
 
+    let query_params: HashMap<String, String> = request
+        .uri()
+        .query()
+        .map(|q| {
+            query_pairs(&Bytes::copy_from_slice(q.as_bytes()))
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect()
+        })
+        .unwrap_or_default();
+
+    let page: usize = query_params
+        .get("page")
+        .map_or(1, |p| p.parse().unwrap_or(1));
+
+    let limit = query_params
+        .get("page_size")
+        .map_or(10, |p| p.parse().unwrap_or(10));
+
+    let total_object_counts = manager.get_total_object_counts(&request).await?;
+    let total_pages = total_object_counts.div_ceil(limit);
+
+    if page == 0 || page > total_pages {
+        return Err(Error::not_found_message(format!("page {page} not found")));
+    }
+
+    let pagination = Pagination::new(limit, page);
+
+    let objects = manager.get_objects(&request, pagination).await?;
+
     let template = ModelTemplate {
         request: &request,
         model: &*manager,
-        objects: manager.get_objects(&request).await?,
+        objects,
+        page,
+        page_size: &limit,
+        total_object_counts,
+        total_pages,
     };
+
     Ok(Response::new_html(
         StatusCode::OK,
         Body::fixed(template.render()?),
@@ -312,7 +379,14 @@ pub trait AdminModelManager: Send + Sync {
     fn url_name(&self) -> &str;
 
     /// Returns the list of objects of this model.
-    async fn get_objects(&self, request: &Request) -> cot::Result<Vec<Box<dyn AdminModel>>>;
+    async fn get_objects(
+        &self,
+        request: &Request,
+        pagination: Pagination,
+    ) -> cot::Result<Vec<Box<dyn AdminModel>>>;
+
+    /// Returns the total count of objects of this model.
+    async fn get_total_object_counts(&self, request: &Request) -> cot::Result<usize>;
 
     /// Returns the object with the given ID.
     async fn get_object_by_id(
@@ -387,9 +461,17 @@ impl<T: AdminModel + Send + Sync + 'static> AdminModelManager for DefaultAdminMo
         T::url_name()
     }
 
-    async fn get_objects(&self, request: &Request) -> cot::Result<Vec<Box<dyn AdminModel>>> {
+    async fn get_total_object_counts(&self, request: &Request) -> cot::Result<usize> {
+        T::get_total_object_counts(request).await
+    }
+
+    async fn get_objects(
+        &self,
+        request: &Request,
+        pagination: Pagination,
+    ) -> cot::Result<Vec<Box<dyn AdminModel>>> {
         #[allow(trivial_casts)] // Upcast to the correct Box type
-        T::get_objects(request).await.map(|objects| {
+        T::get_objects(request, pagination).await.map(|objects| {
             objects
                 .into_iter()
                 .map(|object| Box::new(object) as Box<dyn AdminModel>)
@@ -443,7 +525,12 @@ pub trait AdminModel: Any + Send + 'static {
     fn as_any(&self) -> &dyn Any;
 
     /// Get the objects of this model.
-    async fn get_objects(request: &Request) -> cot::Result<Vec<Self>>
+    async fn get_objects(request: &Request, pagination: Pagination) -> cot::Result<Vec<Self>>
+    where
+        Self: Sized;
+
+    /// Get the total count of objects of this model.
+    async fn get_total_object_counts(request: &Request) -> cot::Result<usize>
     where
         Self: Sized;
 

cot/src/db.rs

@@ -963,6 +963,8 @@ impl Database {
         let mut select = sea_query::Query::select();
         select.columns(columns_to_get).from(T::TABLE_NAME);
         query.add_filter_to_statement(&mut select);
+        query.add_limit_to_statement(&mut select);
+        query.add_offset_to_statement(&mut select);
 
         let rows = self.fetch_all(&select).await?;
         let result = rows.into_iter().map(T::from_db).collect::<Result<_>>()?;

cot/src/db/query.rs

@@ -7,8 +7,8 @@ use sea_query::{ExprTrait, IntoColumnRef};
 
 use crate::db;
 use crate::db::{
-    Auto, DatabaseBackend, DbFieldValue, DbValue, ForeignKey, FromDbValue, Identifier, Model,
-    StatementResult, ToDbFieldValue,
+    Auto, Database, DatabaseBackend, DbFieldValue, DbValue, ForeignKey, FromDbValue, Identifier,
+    Model, StatementResult, ToDbFieldValue,
 };
 
 /// A query that can be executed on a database. Can be used to filter, update,
@@ -32,6 +32,8 @@ use crate::db::{
 /// ```
 pub struct Query<T> {
     filter: Option<Expr>,
+    limit: Option<usize>,
+    offset: Option<usize>,
     phantom_data: PhantomData<fn() -> T>,
 }
 
@@ -40,6 +42,8 @@ impl<T> Debug for Query<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Query")
             .field("filter", &self.filter)
+            .field("limit", &self.limit)
+            .field("offset", &self.offset)
             .field("phantom_data", &self.phantom_data)
             .finish()
     }
@@ -50,6 +54,8 @@ impl<T> Clone for Query<T> {
     fn clone(&self) -> Self {
         Self {
             filter: self.filter.clone(),
+            limit: self.limit,
+            offset: self.offset,
             phantom_data: PhantomData,
         }
     }
@@ -91,6 +97,8 @@ impl<T: Model> Query<T> {
     pub fn new() -> Self {
         Self {
             filter: None,
+            limit: None,
+            offset: None,
             phantom_data: PhantomData,
         }
     }
@@ -118,6 +126,52 @@ impl<T: Model> Query<T> {
         self
     }
 
+    /// Set the limit for the query.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cot::db::model;
+    /// use cot::db::query::{Expr, Query};
+    ///
+    /// #[model]
+    /// struct User {
+    ///     #[model(primary_key)]
+    ///     id: i32,
+    ///     name: String,
+    ///     age: i32,
+    /// }
+    ///
+    /// let query = Query::<User>::new().limit(10);
+    /// ```
+    pub fn limit(&mut self, limit: usize) -> &mut Self {
+        self.limit = Some(limit);
+        self
+    }
+
+    /// Set the offset for the query.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cot::db::model;
+    /// use cot::db::query::{Expr, Query};
+    ///
+    /// #[model]
+    /// struct User {
+    ///     #[model(primary_key)]
+    ///     id: i32,
+    ///     name: String,
+    ///     age: i32,
+    /// }
+    ///
+    /// let query = Query::<User>::new().offset(10);
+    /// ```
+    pub fn offset(&mut self, offset: usize) -> &mut Self {
+        self.offset = Some(offset);
+        self
+    }
+
     /// Execute the query and return all results.
     ///
     /// # Errors
@@ -137,6 +191,25 @@ impl<T: Model> Query<T> {
         db.get(self).await
     }
 
+    /// Execute the query and return the number of results.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the query fails.
+    pub async fn count(&self, db: &Database) -> db::Result<usize> {
+        let mut select = sea_query::Query::select();
+        select
+            .from(T::TABLE_NAME)
+            .expr(sea_query::Expr::col(sea_query::Asterisk).count());
+        self.add_filter_to_statement(&mut select);
+        let row = db.fetch_option(&select).await?;
+        let count = match row {
+            Some(row) => row.get::<i64>(0)? as usize,
+            None => 0,
+        };
+        Ok(count)
+    }
+
     /// Execute the query and check if any results exist.
     ///
     /// # Errors
@@ -163,6 +236,18 @@ impl<T: Model> Query<T> {
             statement.and_where(filter.as_sea_query_expr());
         }
     }
+
+    pub(super) fn add_limit_to_statement(&self, statement: &mut sea_query::SelectStatement) {
+        if let Some(limit) = self.limit {
+            statement.limit(limit as u64);
+        }
+    }
+
+    pub(super) fn add_offset_to_statement(&self, statement: &mut sea_query::SelectStatement) {
+        if let Some(offset) = self.offset {
+            statement.offset(offset as u64);
+        }
+    }
 }
 
 /// An expression that can be used to filter, update, or delete rows.
@@ -1353,13 +1438,17 @@ mod tests {
         let query: Query<MockModel> = Query::new();
 
         assert!(query.filter.is_none());
+        assert!(query.limit.is_none());
+        assert!(query.offset.is_none());
     }
 
     #[test]
     fn query_default() {
         let query: Query<MockModel> = Query::default();
 
         assert!(query.filter.is_none());
+        assert!(query.limit.is_none());
+        assert!(query.offset.is_none());
     }
 
     #[test]
@@ -1371,6 +1460,22 @@ mod tests {
         assert!(query.filter.is_some());
     }
 
+    #[test]
+    fn query_limit() {
+        let mut query: Query<MockModel> = Query::new();
+        query.limit(10);
+        assert!(query.limit.is_some());
+        assert_eq!(query.limit.unwrap(), 10);
+    }
+
+    #[test]
+    fn query_offset() {
+        let mut query: Query<MockModel> = Query::new();
+        query.offset(10);
+        assert!(query.offset.is_some());
+        assert_eq!(query.offset.unwrap(), 10);
+    }
+
     #[cot::test]
     async fn query_all() {
         let mut db = MockDatabaseBackend::new();