umami-api 0.0.2

Easily interact with the Umami API (self-hosted instances)
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

use serde::Deserialize;

use crate::{Umami, UmamiError, users::DetailedUser};

#[derive(Clone, Debug, Deserialize)]
struct OriginalResponse {
  data: Vec<DetailedUser>,
}

pub struct GetUsersRequestBuilder<'a> {
  client: &'a Umami,
  search: Option<String>,
  page: Option<u32>,
  page_size: Option<u32>,
}

impl<'a> GetUsersRequestBuilder<'a> {
  pub fn new(client: &'a Umami) -> Self {
    Self { client, search: None, page: None, page_size: None }
  }

  /// Search text
  pub fn search(mut self, search: impl Into<String>) -> Self {
    self.search = Some(search.into());
    self
  }

  /// Determines page
  pub fn page(mut self, page: impl Into<u32>) -> Self {
    self.page_size = Some(page.into());
    self
  }

  /// Determines how many results to return
  pub fn page_size(mut self, page_size: impl Into<u32>) -> Self {
    self.page_size = Some(page_size.into());
    self
  }

  pub async fn fetch(self) -> Result<Vec<DetailedUser>, UmamiError> {
    let mut parameters: Vec<(&str, String)> = vec![];

    if let Some(search) = self.search {
      parameters.extend(vec![("search", search)]);
    }
    if let Some(page) = self.page {
      parameters.extend(vec![("page", page.to_string())]);
    }
    if let Some(page_size) = self.page_size {
      parameters.extend(vec![("pageSize", page_size.to_string())]);
    }

    let response = self.client.request::<OriginalResponse, _>("get", "admin/users", parameters).await?;
    Ok(response.data)
  }
}

// #[cfg(test)]
// mod tests {
//   use super::*;
//   use std::env;
//   use dotenv::dotenv;
//
//   #[tokio::test]
//   async fn good() {
//     dotenv().ok();
//     let instance = env::var("INSTANCE").expect("INSTANCE has to be set");
//     let username = env::var("USERNAME").expect("USERNAME has to be set");
//     let password = env::var("PASSWORD").expect("PASSWORD has to be set");
//     let api = Umami::new(instance, username, password).await.unwrap();
//
//     let users = api.get_users()
//       .fetch()
//       .await;
//
//     assert!(users.is_ok());
//     assert!(users.unwrap().len() >= 1);
//   }
// }