systemprompt-models 0.1.18

Shared data models and types for systemprompt.io OS
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaginationInfo {
    pub total: i64,

    pub page: i32,

    pub per_page: i32,

    pub total_pages: i32,

    pub has_next: bool,

    pub has_prev: bool,

    pub next_url: Option<String>,

    pub prev_url: Option<String>,
}

impl PaginationInfo {
    pub fn new(total: i64, page: i32, per_page: i32) -> Self {
        let per_page_i64 = i64::from(per_page);
        let total_pages =
            i32::try_from((total + per_page_i64 - 1) / per_page_i64).unwrap_or(i32::MAX);
        let has_next = page < total_pages;
        let has_prev = page > 1;

        Self {
            total,
            page,
            per_page,
            total_pages,
            has_next,
            has_prev,
            next_url: None,
            prev_url: None,
        }
    }

    pub fn with_base_url(mut self, base_url: &str) -> Self {
        if self.has_next {
            self.next_url = Some(format!(
                "{}?page={}&per_page={}",
                base_url,
                self.page + 1,
                self.per_page
            ));
        }
        if self.has_prev {
            self.prev_url = Some(format!(
                "{}?page={}&per_page={}",
                base_url,
                self.page - 1,
                self.per_page
            ));
        }
        self
    }
}

#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
pub struct PaginationParams {
    #[serde(default = "default_page")]
    pub page: i32,

    #[serde(default = "default_per_page")]
    pub per_page: i32,
}

const fn default_page() -> i32 {
    1
}

const fn default_per_page() -> i32 {
    20
}

impl Default for PaginationParams {
    fn default() -> Self {
        Self {
            page: default_page(),
            per_page: default_per_page(),
        }
    }
}

impl PaginationParams {
    pub const fn offset(&self) -> i32 {
        (self.page - 1) * self.per_page
    }

    pub const fn limit(&self) -> i32 {
        self.per_page
    }
}

#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum SortOrder {
    #[default]
    Asc,
    Desc,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SortParams {
    pub sort_by: Option<String>,

    #[serde(default)]
    pub sort_order: SortOrder,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchQuery {
    pub search: Option<String>,
    pub sort_by: Option<String>,
    pub sort_dir: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiQuery {
    #[serde(flatten)]
    pub pagination: PaginationParams,

    #[serde(flatten)]
    pub search: SearchQuery,
}