614 lines
20 KiB
Rust
614 lines
20 KiB
Rust
use reqwest_retry::policies::ExponentialBackoff;
|
|
use std::time::Duration;
|
|
use reqwest_retry::{Jitter, RetryTransientMiddleware};
|
|
use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
|
|
use std::num::NonZero;
|
|
use axum::async_trait;
|
|
use governor::state::{InMemoryState, NotKeyed};
|
|
use governor::clock::DefaultClock;
|
|
use reqwest::header::{HeaderMap, HeaderValue};
|
|
use base64::engine::general_purpose::STANDARD;
|
|
use base64::Engine;
|
|
use chrono::{DateTime, SecondsFormat, Utc};
|
|
use reqwest::Response;
|
|
use serde::de::DeserializeOwned;
|
|
|
|
struct ReqwestRateLimiter {
|
|
rate_limiter: governor::RateLimiter<NotKeyed, InMemoryState, DefaultClock>,
|
|
}
|
|
|
|
impl ReqwestRateLimiter {
|
|
fn new() -> Self {
|
|
Self {
|
|
rate_limiter: governor::RateLimiter::direct(
|
|
governor::Quota::per_second(NonZero::new(1u32).unwrap())
|
|
),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl reqwest_ratelimit::RateLimiter for ReqwestRateLimiter {
|
|
async fn acquire_permit(&self) {
|
|
// We don't need to introduce jitter here as that is handled by the retry_request
|
|
// middleware.
|
|
self.rate_limiter.until_ready().await;
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct TogglApi {
|
|
client: ClientWithMiddleware,
|
|
pub workspace_id: u64,
|
|
headers: HeaderMap,
|
|
}
|
|
|
|
const BASE_URL: &str = "https://api.track.toggl.com/api/v9";
|
|
const REPORTS_BASE_URL: &str = "https://api.track.toggl.com/reports/api/v3";
|
|
|
|
impl TogglApi {
|
|
pub fn new(api_key: &str, workspace_id: u64) -> Self {
|
|
let rate_limiter = ReqwestRateLimiter::new();
|
|
let backoff = ExponentialBackoff::builder()
|
|
.retry_bounds(Duration::from_secs(1), Duration::from_secs(60))
|
|
.jitter(Jitter::Bounded)
|
|
.base(2)
|
|
.build_with_total_retry_duration(Duration::from_secs(24 * 60 * 60));
|
|
|
|
let client = ClientBuilder::new(reqwest::Client::new())
|
|
.with(reqwest_ratelimit::all(rate_limiter))
|
|
.with(RetryTransientMiddleware::new_with_policy(backoff))
|
|
.build();
|
|
|
|
let toggl_auth = &STANDARD.encode(format!("{}:api_token", api_key));
|
|
let headers = Self::authorisation_headers(toggl_auth);
|
|
|
|
Self { client, workspace_id, headers }
|
|
}
|
|
|
|
fn authorisation_headers(toggl_auth: &str) -> HeaderMap {
|
|
let mut headers = HeaderMap::new();
|
|
let mut value = HeaderValue::from_str(&format!("Basic {}", toggl_auth)).unwrap();
|
|
value.set_sensitive(true);
|
|
headers.insert("Authorization", value);
|
|
headers.insert("Content-Type", HeaderValue::from_static("application/json"));
|
|
headers
|
|
}
|
|
|
|
/// Get the workspaces that a user is a part of
|
|
#[tracing::instrument(skip(self))]
|
|
async fn get_users_workspaces(
|
|
&self
|
|
) -> Result<Vec<types::Workspace>, TogglError> {
|
|
let url = format!("{base_url}/me/workspaces", base_url = BASE_URL);
|
|
|
|
let response = self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send().await?;
|
|
|
|
let data = response.text().await?;
|
|
let workspaces: Vec<types::Workspace> = serde_json::from_str(&data)?;
|
|
|
|
Ok(workspaces)
|
|
}
|
|
|
|
/// Get a specific workspace by its ID
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_workspace(&self, id: u64) -> Result<types::Workspace, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/workspaces/{id}",
|
|
base_url = BASE_URL,
|
|
id = id
|
|
);
|
|
|
|
Self::parse(self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send().await?).await
|
|
}
|
|
|
|
/// Fetches all time entries for this user from Toggl that have been modified since the given
|
|
/// date.
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_time_entries_for_user_modified_since(&self, since: DateTime<Utc>) -> Result<Vec<types::TimeEntry>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/me/time_entries?since={since}",
|
|
base_url = BASE_URL,
|
|
since = since.timestamp()
|
|
);
|
|
|
|
Self::parse(self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send().await?).await
|
|
}
|
|
|
|
/// Fetches all time entries for this user from Toggl that have a start time between the given
|
|
/// start and end times.
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_time_user_entries_between(&self, start: DateTime<Utc>, until: DateTime<Utc>) -> Result<Vec<types::TimeEntry>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/me/time_entries",
|
|
base_url = BASE_URL,
|
|
);
|
|
|
|
Self::parse(self.client.get(url)
|
|
.headers(self.headers.clone())
|
|
.query(&[
|
|
("start_date", start.to_rfc3339_opts(SecondsFormat::Secs, true)),
|
|
("end_date", until.to_rfc3339_opts(SecondsFormat::Secs, true)),
|
|
])
|
|
.send().await?).await
|
|
}
|
|
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_current_time_entry(&self) -> Result<Option<types::TimeEntry>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/me/time_entries/current",
|
|
base_url = BASE_URL
|
|
);
|
|
|
|
Ok(self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send()
|
|
.await?
|
|
.json().await?)
|
|
}
|
|
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_projects(&self) -> Result<Vec<types::Project>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/workspaces/{workspace_id}/projects",
|
|
base_url = BASE_URL,
|
|
workspace_id = self.workspace_id
|
|
);
|
|
|
|
Self::parse(self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send().await?).await
|
|
}
|
|
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_clients(&self) -> Result<Vec<types::TrackingClient>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/workspaces/{workspace_id}/clients",
|
|
base_url = BASE_URL,
|
|
workspace_id = self.workspace_id
|
|
);
|
|
|
|
Self::parse(self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send().await?).await
|
|
}
|
|
|
|
async fn parse<T: DeserializeOwned>(response: Response) -> Result<T, TogglError> {
|
|
let data = response.text().await?;
|
|
let result = serde_json_path_to_error::from_str(&data);
|
|
|
|
let result = result
|
|
.map_err(|error| TogglError::JsonWithDataError {
|
|
data,
|
|
error,
|
|
})?;
|
|
|
|
Ok(result)
|
|
}
|
|
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn get_tags(&self) -> Result<Vec<types::Tag>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/workspaces/{workspace_id}/tags",
|
|
base_url = BASE_URL,
|
|
workspace_id = self.workspace_id
|
|
);
|
|
|
|
Self::parse(self.client.get(&url)
|
|
.headers(self.headers.clone())
|
|
.send().await?).await
|
|
}
|
|
|
|
fn paginate_filters(original_filters: &types::TogglReportFilters, last_row_id: u64) -> types::TogglReportFilters {
|
|
let mut filters = original_filters.clone();
|
|
filters.first_row_number = Some(last_row_id + 1);
|
|
filters
|
|
}
|
|
|
|
#[tracing::instrument(skip(self))]
|
|
pub async fn search(&self, workspace_id: u64, filters: types::TogglReportFilters) -> Result<Vec<types::ReportEntry>, TogglError> {
|
|
let url = format!(
|
|
"{base_url}/workspace/{workspace_id}/search/time_entries",
|
|
base_url = &REPORTS_BASE_URL,
|
|
workspace_id = workspace_id,
|
|
);
|
|
|
|
let mut last_row_number = Some(0);
|
|
let mut results = vec![];
|
|
|
|
while let Some(last_row_number_n) = last_row_number {
|
|
// If we are not on the first page, wait a bit to avoid rate limiting
|
|
if last_row_number_n != 0 {
|
|
tokio::time::sleep(Duration::from_secs(1)).await;
|
|
}
|
|
|
|
let data: Vec<types::ReportEntry> = Self::parse(self.client.post(&url)
|
|
.headers(self.headers.clone())
|
|
.json(&Self::paginate_filters(&filters, last_row_number_n))
|
|
.send().await?).await?;
|
|
|
|
last_row_number = data.last().map(|e| e.row_number as u64);
|
|
|
|
data.into_iter().for_each(|e| results.push(e));
|
|
}
|
|
|
|
Ok(results)
|
|
}
|
|
}
|
|
|
|
pub mod types {
|
|
use std::collections::HashMap;
|
|
use chrono::{DateTime, NaiveDate, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_with::skip_serializing_none;
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone, Soars)]
|
|
pub struct TimeEntry {
|
|
pub id: u64,
|
|
pub workspace_id: u64,
|
|
pub user_id: u64,
|
|
pub project_id: Option<u64>,
|
|
pub task_id: Option<u64>,
|
|
|
|
pub start: DateTime<Utc>,
|
|
pub stop: Option<DateTime<Utc>>,
|
|
|
|
#[serde(with = "duration_field")]
|
|
pub duration: Option<u32>,
|
|
|
|
#[serde(rename = "at")]
|
|
pub updated_at: DateTime<Utc>,
|
|
|
|
pub description: Option<String>,
|
|
|
|
#[serde(default)]
|
|
pub tags: Vec<String>,
|
|
|
|
#[serde(default)]
|
|
pub tag_ids: Vec<u64>,
|
|
|
|
pub billable: bool,
|
|
pub server_deleted_at: Option<DateTime<Utc>>,
|
|
pub permissions: Option<String>,
|
|
}
|
|
|
|
mod duration_field {
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
pub fn serialize<S>(duration: &Option<u32>, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
match duration {
|
|
None => i32::serialize(&-1, serializer),
|
|
Some(duration) => i32::serialize(&(*duration as i32), serializer),
|
|
}
|
|
}
|
|
|
|
pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<u32>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let duration = i32::deserialize(deserializer)?;
|
|
if duration < 0 {
|
|
Ok(None)
|
|
} else {
|
|
Ok(Some(duration as u32))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone, Soars)]
|
|
pub struct Project {
|
|
pub id: i64,
|
|
pub workspace_id: i64,
|
|
pub client_id: Option<i64>,
|
|
|
|
pub name: String,
|
|
pub color: String,
|
|
pub status: ProjectStatus,
|
|
pub active: bool,
|
|
|
|
#[serde(rename = "at")]
|
|
pub updated_at: DateTime<Utc>,
|
|
pub start_date: NaiveDate,
|
|
pub created_at: DateTime<Utc>,
|
|
pub server_deleted_at: Option<DateTime<Utc>>,
|
|
|
|
pub actual_hours: Option<i64>,
|
|
pub actual_seconds: Option<i64>,
|
|
pub can_track_time: bool,
|
|
pub permissions: Option<String>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
#[serde(rename_all = "lowercase")]
|
|
pub enum ProjectStatus {
|
|
Upcoming,
|
|
Active,
|
|
Archived,
|
|
Ended,
|
|
Deleted,
|
|
}
|
|
|
|
impl fmt::Display for ProjectStatus {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "{}", match self {
|
|
ProjectStatus::Upcoming => "upcoming",
|
|
ProjectStatus::Active => "active",
|
|
ProjectStatus::Archived => "archived",
|
|
ProjectStatus::Ended => "ended",
|
|
ProjectStatus::Deleted => "deleted",
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone, Soars)]
|
|
pub struct TrackingClient {
|
|
/// The unique identifier for the client.
|
|
pub id: i64,
|
|
|
|
/// Represents the timestamp of the last update made to the client.
|
|
#[serde(rename = "at")]
|
|
pub updated_at: DateTime<Utc>,
|
|
|
|
/// Indicates whether the client is archived or not.
|
|
pub archived: bool,
|
|
|
|
pub creator_id: i64,
|
|
pub integration_provider: Option<String>,
|
|
pub notes: Option<String>,
|
|
|
|
/// The name of the client.
|
|
pub name: String,
|
|
|
|
/// Indicates the timestamp when the client was deleted. If the client is not deleted, this property will be null.
|
|
pub server_deleted_at: Option<DateTime<Utc>>,
|
|
|
|
/// The Workspace ID associated with the client.
|
|
#[serde(rename = "wid")]
|
|
pub workspace_id: i64,
|
|
|
|
pub permissions: Option<String>,
|
|
}
|
|
|
|
#[derive(Soars, Serialize, Deserialize, Debug, Clone)]
|
|
pub struct Tag {
|
|
pub id: u64,
|
|
pub name: String,
|
|
pub workspace_id: u64,
|
|
pub creator_id: u64,
|
|
#[serde(rename = "at")]
|
|
pub updated_at: DateTime<Utc>,
|
|
pub deleted_at: Option<DateTime<Utc>>,
|
|
pub permissions: Option<String>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
pub struct ReportEntry {
|
|
pub user_id: u64,
|
|
pub username: String,
|
|
pub project_id: Option<u64>,
|
|
pub task_id: Option<u64>,
|
|
pub billable: bool,
|
|
pub description: Option<String>,
|
|
pub tag_ids: Vec<u64>,
|
|
pub billable_amount_in_cents: Option<u64>,
|
|
pub hourly_rate_in_cents: Option<u64>,
|
|
pub currency: String,
|
|
pub time_entries: Vec<ReportEntryTimeDetails>,
|
|
pub row_number: u32,
|
|
|
|
#[serde(flatten)]
|
|
pub enriched_information: Option<ReportEntryEnrichedInfo>,
|
|
|
|
#[serde(flatten)]
|
|
pub rest: HashMap<String, serde_json::Value>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
pub struct ReportEntryEnrichedInfo {
|
|
pub project_id: Option<u64>,
|
|
pub project_name: Option<String>,
|
|
pub project_hex: Option<String>,
|
|
|
|
pub tag_names: Vec<String>,
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize, Debug)]
|
|
pub struct ReportEntryTimeDetails {
|
|
pub id: u64,
|
|
pub seconds: u32,
|
|
pub start: DateTime<Utc>,
|
|
pub stop: DateTime<Utc>,
|
|
#[serde(rename = "at")]
|
|
pub updated_at: DateTime<Utc>,
|
|
}
|
|
|
|
impl ReportEntry {
|
|
pub fn into_time_entry(self, workspace_id: u64) -> TimeEntry {
|
|
TimeEntry {
|
|
id: self.time_entries[0].id,
|
|
workspace_id,
|
|
user_id: self.user_id,
|
|
project_id: self.project_id,
|
|
task_id: self.task_id,
|
|
start: self.time_entries[0].start,
|
|
stop: Some(self.time_entries[0].stop),
|
|
duration: Some(self.time_entries[0].seconds),
|
|
updated_at: self.time_entries[0].updated_at,
|
|
description: self.description,
|
|
tags: self.enriched_information
|
|
.map(|e| e.tag_names.clone())
|
|
.unwrap_or_default(),
|
|
|
|
tag_ids: self.tag_ids,
|
|
billable: self.billable,
|
|
server_deleted_at: None,
|
|
permissions: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[skip_serializing_none]
|
|
#[derive(Serialize, Deserialize, Clone, Default)]
|
|
pub struct TogglReportFilters {
|
|
pub billable: Option<bool>,
|
|
pub client_ids: Option<Vec<u64>>,
|
|
pub description: Option<String>,
|
|
pub end_date: Option<NaiveDate>,
|
|
pub enrich_response: Option<bool>,
|
|
pub first_id: Option<u64>,
|
|
pub first_row_number: Option<u64>,
|
|
pub first_timestamp: Option<u64>,
|
|
pub group_ids: Option<Vec<u64>>,
|
|
pub grouped: Option<bool>,
|
|
pub hide_amounts: Option<bool>,
|
|
pub max_duration_seconds: Option<u64>,
|
|
pub min_duration_seconds: Option<u64>,
|
|
pub order_by: Option<String>,
|
|
pub order_dir: Option<String>,
|
|
pub page_size: Option<u64>,
|
|
#[serde(rename = "postedFields")]
|
|
pub posted_fields: Option<Vec<String>>,
|
|
pub project_ids: Option<Vec<u64>>,
|
|
pub rounding: Option<u64>,
|
|
pub rounding_minutes: Option<u64>,
|
|
#[serde(rename = "startTime")]
|
|
pub start_time: Option<String>,
|
|
pub start_date: Option<NaiveDate>,
|
|
pub tag_ids: Option<Vec<u64>>,
|
|
pub task_ids: Option<Vec<u64>>,
|
|
pub time_entry_ids: Option<Vec<u64>>,
|
|
pub user_ids: Option<Vec<u64>>,
|
|
|
|
#[serde(flatten)]
|
|
pub rest: HashMap<String, serde_json::Value>,
|
|
}
|
|
|
|
use std::fmt;
|
|
use soa_rs::Soars;
|
|
|
|
impl fmt::Debug for TogglReportFilters {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let mut ds = f.debug_struct("TogglQuery");
|
|
|
|
if let Some(billable) = &self.billable {
|
|
ds.field("billable", billable);
|
|
}
|
|
if let Some(client_ids) = &self.client_ids {
|
|
ds.field("client_ids", client_ids);
|
|
}
|
|
if let Some(description) = &self.description {
|
|
ds.field("description", description);
|
|
}
|
|
if let Some(end_date) = &self.end_date {
|
|
ds.field("end_date", end_date);
|
|
}
|
|
if let Some(first_id) = &self.first_id {
|
|
ds.field("first_id", first_id);
|
|
}
|
|
if let Some(first_row_number) = &self.first_row_number {
|
|
ds.field("first_row_number", first_row_number);
|
|
}
|
|
if let Some(first_timestamp) = &self.first_timestamp {
|
|
ds.field("first_timestamp", first_timestamp);
|
|
}
|
|
if let Some(group_ids) = &self.group_ids {
|
|
ds.field("group_ids", group_ids);
|
|
}
|
|
if let Some(grouped) = &self.grouped {
|
|
ds.field("grouped", grouped);
|
|
}
|
|
if let Some(hide_amounts) = &self.hide_amounts {
|
|
ds.field("hide_amounts", hide_amounts);
|
|
}
|
|
if let Some(max_duration_seconds) = &self.max_duration_seconds {
|
|
ds.field("max_duration_seconds", max_duration_seconds);
|
|
}
|
|
if let Some(min_duration_seconds) = &self.min_duration_seconds {
|
|
ds.field("min_duration_seconds", min_duration_seconds);
|
|
}
|
|
if let Some(order_by) = &self.order_by {
|
|
ds.field("order_by", order_by);
|
|
}
|
|
if let Some(order_dir) = &self.order_dir {
|
|
ds.field("order_dir", order_dir);
|
|
}
|
|
if let Some(posted_fields) = &self.posted_fields {
|
|
ds.field("postedFields", posted_fields);
|
|
}
|
|
if let Some(project_ids) = &self.project_ids {
|
|
ds.field("project_ids", project_ids);
|
|
}
|
|
if let Some(rounding) = &self.rounding {
|
|
ds.field("rounding", rounding);
|
|
}
|
|
if let Some(rounding_minutes) = &self.rounding_minutes {
|
|
ds.field("rounding_minutes", rounding_minutes);
|
|
}
|
|
if let Some(start_time) = &self.start_time {
|
|
ds.field("startTime", start_time);
|
|
}
|
|
if let Some(start_date) = &self.start_date {
|
|
ds.field("start_date", start_date);
|
|
}
|
|
if let Some(tag_ids) = &self.tag_ids {
|
|
ds.field("tag_ids", tag_ids);
|
|
}
|
|
if let Some(task_ids) = &self.task_ids {
|
|
ds.field("task_ids", task_ids);
|
|
}
|
|
if let Some(time_entry_ids) = &self.time_entry_ids {
|
|
ds.field("time_entry_ids", time_entry_ids);
|
|
}
|
|
if let Some(user_ids) = &self.user_ids {
|
|
ds.field("user_ids", user_ids);
|
|
}
|
|
|
|
if !self.rest.is_empty() {
|
|
ds.field("rest", &self.rest);
|
|
}
|
|
|
|
ds.finish()
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Clone, Soars)]
|
|
pub struct Workspace {
|
|
pub id: u64,
|
|
pub organization_id: u64,
|
|
pub name: String,
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum TogglError {
|
|
#[error("Toggl returned error: {0}")]
|
|
TogglError(serde_json::Value),
|
|
|
|
#[error("Reqwest error: {0}")]
|
|
ReqwestError(#[from] reqwest_middleware::Error),
|
|
|
|
#[error("Json error: {0}")]
|
|
JsonError(#[from] serde_json::Error),
|
|
|
|
#[error("Failed to parse JSON data: {data}, error: {error}")]
|
|
JsonWithDataError {
|
|
data: String,
|
|
error: serde_json_path_to_error::Error,
|
|
},
|
|
}
|
|
|
|
impl From<reqwest::Error> for TogglError {
|
|
fn from(value: reqwest::Error) -> Self {
|
|
TogglError::ReqwestError(reqwest_middleware::Error::Reqwest(value))
|
|
}
|
|
}
|