loco-rs 0.4.0

The one-person framework for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// use sea_orm::{prelude::*, DatabaseConnection, EntityTrait, PaginatorTrait,
// Select, SelectorTrait};
use sea_orm::{prelude::*, Condition, DatabaseConnection, EntityTrait, QueryFilter};
use serde::Deserialize;

#[allow(deprecated)]
use crate::{
    controller::views::pagination::{Pager, PagerMeta, PaginationResponseTrait},
    Result as LocoResult,
};

/// Set the default pagination page size
const fn default_page_size() -> u64 {
    10
}

/// Set the default pagination page
const fn default_page() -> u64 {
    1
}

#[derive(Debug, Deserialize)]
pub struct PaginationFilter {
    #[serde(
        default = "default_page_size",
        rename = "page_size",
        deserialize_with = "deserialize_pagination_filter"
    )]
    pub page_size: u64,
    #[serde(
        default = "default_page",
        rename = "page",
        deserialize_with = "deserialize_pagination_filter"
    )]
    pub page: u64,
}

/// Parse the parameters to u64 following a bug in `serde_urlencoded`
fn deserialize_pagination_filter<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let s: String = Deserialize::deserialize(deserializer)?;
    s.parse().map_err(serde::de::Error::custom)
}

#[derive(Debug)]
pub struct PaginatedResponse<T> {
    pub rows: Vec<T>,
    pub page: u64,
    pub page_size: u64,
    pub total_pages: u64,
}

/// Paginates a database query for a given entity, applying optional filters and
/// pagination settings. After paginate the db rows result sends to
/// `PaginationResponseTrait` for prepare json response.
///
/// # Errors
/// when could not fetch the entity query
#[deprecated(
    since = "0.3.2",
    note = "reshape pagination functionality by moving under models. read more https://loco.rs/docs/the-app/pagination"
)]
pub async fn view<R, E>(
    db: &DatabaseConnection,
    entity: Select<E>,
    filters: Option<Condition>,
    pagination_filter: &PaginationFilter,
) -> LocoResult<Pager<Vec<<R as PaginationResponseTrait>::ResponseType>>>
where
    E: EntityTrait,
    <E as EntityTrait>::Model: Sync,
    R: PaginationResponseTrait<Model = E>,
{
    #![allow(deprecated)]
    let res = paginate::<R, E>(db, entity, filters, pagination_filter).await?;

    let res = Pager {
        results: R::list(res.rows),
        info: PagerMeta {
            page: res.page,
            page_size: res.page_size,
            total_pages: res.total_pages,
        },
    };

    Ok(res)
}

/// Paginates a database query for a given entity, applying optional filters and
/// pagination settings.
///
/// # Errors
/// when could not fetch the entity query
#[deprecated(
    since = "0.3.2",
    note = "reshape pagination functionality by moving under models. read more https://loco.rs/docs/the-app/pagination"
)]
pub async fn paginate<R, E>(
    db: &DatabaseConnection,
    entity: Select<E>,
    filters: Option<Condition>,
    pagination_filter: &PaginationFilter,
) -> LocoResult<PaginatedResponse<<E as EntityTrait>::Model>>
where
    E: EntityTrait,
    <E as EntityTrait>::Model: Sync,
    R: PaginationResponseTrait<Model = E>,
{
    #![allow(deprecated)]
    let page = if pagination_filter.page <= 1 {
        0
    } else {
        pagination_filter.page - 1
    };
    let entity = if let Some(filter) = filters {
        entity.filter(filter)
    } else {
        entity
    };

    let query = entity.paginate(db, pagination_filter.page_size);
    let page_count = query.num_pages().await?;
    let rows: Vec<<E as EntityTrait>::Model> = query.fetch_page(page).await?;

    let paginated_response = PaginatedResponse {
        rows,
        page: pagination_filter.page,
        page_size: pagination_filter.page_size,
        total_pages: page_count,
    };

    Ok(paginated_response)
}