pocketbase_sdk/
logs.rs

1use crate::client::{Auth, Client};
2use crate::httpc::Httpc;
3use anyhow::Result;
4use serde::Deserialize;
5use std::collections::HashMap;
6
7pub struct LogsManager<'a> {
8    pub client: &'a Client<Auth>,
9}
10
11#[derive(Debug, Clone)]
12pub struct LogListRequestBuilder<'a> {
13    pub client: &'a Client<Auth>,
14    pub page: i32,
15    pub per_page: i32,
16    pub sort: Option<&'a str>,
17    pub filter: Option<&'a str>,
18}
19
20#[derive(Debug, Clone)]
21pub struct LogViewRequestBuilder<'a> {
22    pub client: &'a Client<Auth>,
23    pub id: &'a str,
24}
25
26#[derive(Debug, Clone)]
27pub struct LogStatisticsRequestBuilder<'a> {
28    pub client: &'a Client<Auth>,
29    pub filter: Option<&'a str>,
30}
31
32#[derive(Debug, Clone, Deserialize)]
33#[serde(rename_all = "camelCase")]
34pub struct LogListItem {
35    pub id: String,
36    pub created: String,
37    pub updated: String,
38    pub url: String,
39    pub method: String,
40    pub status: i32,
41    pub ip: Option<String>,
42    pub referer: String,
43    pub user_agent: String,
44    pub meta: HashMap<String, String>,
45}
46
47#[derive(Debug, Clone, Deserialize)]
48#[serde(rename_all = "camelCase")]
49pub struct LogList {
50    pub page: i32,
51    pub per_page: i32,
52    pub total_items: i32,
53    pub items: Vec<LogListItem>,
54}
55
56#[derive(Debug, Clone, Deserialize)]
57pub struct LogStatDataPoint {
58    pub total: i32,
59    pub date: String,
60}
61
62impl<'a> LogStatisticsRequestBuilder<'a> {
63    pub fn filter(&self, filter_query: &'a str) -> Self {
64        Self {
65            filter: Some(filter_query),
66            ..self.clone()
67        }
68    }
69
70    pub fn call(&self) -> Result<Vec<LogStatDataPoint>> {
71        let url = format!("{}/api/logs/requests/stats", self.client.base_url);
72        let mut build_opts = Vec::new();
73        if let Some(filter_opts) = &self.filter {
74            build_opts.push(("filter", filter_opts.to_owned()));
75        }
76
77        match Httpc::get(self.client, &url, Some(build_opts)) {
78            Ok(result) => {
79                let response = result.into_json::<Vec<LogStatDataPoint>>()?;
80                Ok(response)
81            }
82            Err(e) => Err(e),
83        }
84    }
85}
86
87impl<'a> LogViewRequestBuilder<'a> {
88    pub fn call(&self) -> Result<LogListItem> {
89        let url = format!("{}/api/logs/requests/{}", self.client.base_url, self.id);
90        match Httpc::get(self.client, &url, None) {
91            Ok(result) => {
92                let response = result.into_json::<LogListItem>()?;
93                Ok(response)
94            }
95            Err(e) => Err(e),
96        }
97    }
98}
99
100impl<'a> LogListRequestBuilder<'a> {
101    pub fn page(&self, page_count: i32) -> Self {
102        LogListRequestBuilder {
103            page: page_count,
104            ..self.clone()
105        }
106    }
107
108    pub fn per_page(&self, per_page_count: i32) -> Self {
109        LogListRequestBuilder {
110            per_page: per_page_count,
111            ..self.clone()
112        }
113    }
114
115    pub fn filter(&self, filter_opts: &'a str) -> Self {
116        LogListRequestBuilder {
117            filter: Some(filter_opts),
118            ..self.clone()
119        }
120    }
121
122    pub fn sort(&self, sort_opts: &'a str) -> Self {
123        LogListRequestBuilder {
124            sort: Some(sort_opts),
125            ..self.clone()
126        }
127    }
128
129    pub fn call(&self) -> Result<LogList> {
130        let url = format!("{}/api/logs/requests", self.client.base_url);
131        let mut build_opts = Vec::new();
132
133        if let Some(sort_opts) = &self.sort { build_opts.push(("sort", sort_opts.to_owned())) }
134        if let Some(filter_opts) = &self.filter { build_opts.push(("filter", filter_opts.to_owned())) }
135        let per_page_opts = self.per_page.to_string();
136        let page_opts = self.page.to_string();
137        build_opts.push(("per_page", per_page_opts.as_str()));
138        build_opts.push(("page", page_opts.as_str()));
139
140        match Httpc::get(self.client, &url, Some(build_opts)) {
141            Ok(result) => {
142                let response = result.into_json::<LogList>()?;
143                Ok(response)
144            }
145            Err(e) => Err(e),
146        }
147    }
148}
149
150impl<'a> LogsManager<'a> {
151    pub fn list(&self) -> LogListRequestBuilder<'a> {
152        LogListRequestBuilder {
153            client: self.client,
154            page: 1,
155            per_page: 100,
156            sort: None,
157            filter: None,
158        }
159    }
160
161    pub fn view(&self, id: &'a str) -> LogViewRequestBuilder<'a> {
162        LogViewRequestBuilder {
163            client: self.client,
164            id,
165        }
166    }
167
168    pub fn statistics(&self) -> LogStatisticsRequestBuilder<'a> {
169        LogStatisticsRequestBuilder { client: self.client, filter: None } 
170    }
171}
pocketbase_sdk/logs.rs

pocketbase_sdk/
logs.rs
