commit 781e25470b158bbd829d094474221a2fae5e867d Author: Jonas Rabenstein Date: Mon Feb 16 02:51:10 2026 +0100 initial git dump diff --git a/api/Cargo.toml b/api/Cargo.toml new file mode 100644 index 0000000..c9643b8 --- /dev/null +++ b/api/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "spond" +version = "0.1.0" +edition = "2024" + +[features] +reqwest = [ "dep:reqwest", "reqwest/json" ] +log = [ "tracing/log" ] +tracing = [ ] +cookies = [ "reqwest?/cookies" ] + + +[dependencies] +async-trait = "0.1.89" +bon = "3.9.0" +bytes = "1.11.1" +chrono = { version = "0.4.43", features = ["serde"] } +#macro = { path = "../macro" } +reqwest = { version = "0.13.2", optional = true } +serde = { version = "1.0.228", features = ["derive"] } +serde_json = "1.0.149" +#spond-auth-login = { version = "0.1.0", path = "../login" } +thiserror = "2.0.18" +tokio = { version = "1.49.0" } +tracing = { version = "0.1.44", features = [] } +url = "2.5.8" + +[dev-dependencies] +tokio = { version = "1.49.0", features = ["macros"] } diff --git a/api/src/authentication/login/email.rs b/api/src/authentication/login/email.rs new file mode 100644 index 0000000..678b60b --- /dev/null +++ b/api/src/authentication/login/email.rs @@ -0,0 +1,16 @@ +#[derive(Debug, serde::Serialize)] +pub struct Email { + email: String, + password: String, +} + +impl Email { + pub fn new(email: &str, password: &str) -> Self { + Self { + email: email.to_string(), + password: password.to_string(), + } + } +} + +impl super::Credentials for Email {} diff --git a/api/src/authentication/login/mod.rs b/api/src/authentication/login/mod.rs new file mode 100644 index 0000000..8ac83b5 --- /dev/null +++ b/api/src/authentication/login/mod.rs @@ -0,0 +1,22 @@ +mod email; +mod phone; + +pub use email::Email; +pub use phone::Phone; + +use crate::{ + Method, + authentication::Tokens, + traits::{authentication::login::Credentials, endpoint}, +}; + +pub struct Login; + +impl endpoint::Public for Login { + const METHOD: Method = Method::POST; + type Schema = Tokens; + + fn path(&self, _: &C) -> &str { + "core/v1/auth2/login" + } +} diff --git a/api/src/authentication/login/phone.rs b/api/src/authentication/login/phone.rs new file mode 100644 index 0000000..ad68c23 --- /dev/null +++ b/api/src/authentication/login/phone.rs @@ -0,0 +1,16 @@ +#[derive(Debug, serde::Serialize)] +pub struct Phone { + phone: String, + password: String, +} + +impl Phone { + pub fn new(phone: &str, password: &str) -> Self { + Self { + phone: phone.to_string(), + password: password.to_string(), + } + } +} + +impl super::Credentials for Phone {} diff --git a/api/src/authentication/mod.rs b/api/src/authentication/mod.rs new file mode 100644 index 0000000..bba562c --- /dev/null +++ b/api/src/authentication/mod.rs @@ -0,0 +1,14 @@ +pub mod login; +pub mod token; + +pub use login::Login; +pub use token::Token; + +use serde::Deserialize; + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Tokens { + pub access_token: token::Access, + pub refresh_token: token::Refresh, +} diff --git a/api/src/authentication/token.rs b/api/src/authentication/token.rs new file mode 100644 index 0000000..a7bdce8 --- /dev/null +++ b/api/src/authentication/token.rs @@ -0,0 +1,74 @@ +use crate::traits::Request; +use chrono::{DateTime, Utc}; +use serde::{Deserialize, Serialize}; + +use std::ops::Deref; + +#[derive(Debug, Clone, Deserialize)] +pub struct Access(Expire); + +impl Deref for Access { + type Target = Expire; + + fn deref(&self) -> &Expire { + &self.0 + } +} + +#[derive(Debug, Clone, Deserialize, Serialize)] +pub struct Refresh(Expire); + +impl Deref for Refresh { + type Target = Expire; + + fn deref(&self) -> &Expire { + &self.0 + } +} + +#[derive(Debug, Clone, Deserialize, Serialize)] +pub struct Token { + token: String, +} + +impl AsRef for Token { + fn as_ref(&self) -> &str { + &self.token + } +} + +#[derive(Debug, Clone, Deserialize, Serialize)] +pub struct Expire { + #[serde(flatten)] + token: Token, + #[serde(skip_serializing)] + expiration: DateTime, +} + +impl Expire { + pub fn expired(&self) -> bool { + Utc::now() <= self.expiration + } +} + +impl Deref for Expire { + type Target = Token; + + fn deref(&self) -> &Token { + &self.token + } +} + +trait Factory: Serialize {} +impl Factory for Refresh {} +impl Factory for Token {} + +impl crate::traits::endpoint::Public for R +{ + const METHOD: crate::Method = crate::Method::POST; + type Schema = super::Tokens; + + fn path(&self, _: &R) -> &str { + "auth2/refresh" + } +} diff --git a/api/src/authorization.rs b/api/src/authorization.rs new file mode 100644 index 0000000..19c38d5 --- /dev/null +++ b/api/src/authorization.rs @@ -0,0 +1,2 @@ +pub struct True; +pub struct False; diff --git a/api/src/error.rs b/api/src/error.rs new file mode 100644 index 0000000..92ae258 --- /dev/null +++ b/api/src/error.rs @@ -0,0 +1,67 @@ +use thiserror::Error; + +pub mod api { + use thiserror::Error; + + pub type Refresh = Public; + + #[derive(Debug, Error)] + pub enum Private { + #[error("endpoint url")] + Url(url::ParseError), + + #[error("json decode")] + Decode(Decode), + + #[error("unauthorized")] + Unauthorized, + + #[error("token refresh")] // TODO: serde_json::Error -> Schema::...? + Refresh(Refresh), + + #[error("send error")] + Send(Transfer), + + #[error("receive error")] + Receive(Transfer), + } + + #[derive(Debug, Error)] + pub enum Public { + #[error("endpoint url")] + Url(url::ParseError), + + #[error("json decode")] + Decode(Decode), + + #[error("send error")] + Send(Transfer), + + #[error("receive error")] + Receive(Transfer), + } +} + +#[derive(Debug, Error)] +pub enum Id { + #[error("invalid length")] + Length(usize), + + #[error("invalid symbol")] + Parser(#[from] std::num::ParseIntError), +} + +#[derive(Debug, Error)] +pub enum Authorization { + #[error("unauthorized")] + Unauthorized, +} + +//#[derive(Debug, Error)] +//pub enum Authentication { +// #[error("unauthorized")] +// Public(A), +// +// #[error("authorized")] +// Private(B), +//} diff --git a/api/src/id.rs b/api/src/id.rs new file mode 100644 index 0000000..b4c4003 --- /dev/null +++ b/api/src/id.rs @@ -0,0 +1,50 @@ +use serde::{Serialize, Deserialize}; +use std::{ + fmt, + str::FromStr, + ops::Deref, +}; + +use crate::{ + utils::X128, + traits::id::Marker, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct Id { + #[serde(flatten)] + id: X128, + #[serde(skip)] + _marker: std::marker::PhantomData, +} + +impl Id { + pub fn new(value: impl Into) -> Self { + Self { + id: value.into(), + _marker: std::marker::PhantomData, + } + } +} + +impl Deref for Id { + type Target = X128; + + fn deref(&self) -> &X128 { + &self.id + } +} + +impl fmt::Display for Id { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.id) + } +} + +impl FromStr for Id { + type Err = ::Err; + + fn from_str(s: &str) -> Result { + X128::from_str(s).map(Self::new) + } +} diff --git a/api/src/lib.rs b/api/src/lib.rs new file mode 100644 index 0000000..0fdb56e --- /dev/null +++ b/api/src/lib.rs @@ -0,0 +1,20 @@ +pub mod authentication; +pub mod authorization; +pub mod error; +pub mod id; +pub mod schema; +pub mod traits; + +mod utils; + +#[derive(Debug)] +pub enum Method { + GET, + POST, +} + +pub use id::Id; + + +#[cfg(feature = "reqwest")] +pub mod reqwest; diff --git a/api/src/reqwest/client.rs b/api/src/reqwest/client.rs new file mode 100644 index 0000000..d2e59e7 --- /dev/null +++ b/api/src/reqwest/client.rs @@ -0,0 +1,133 @@ +use async_trait::async_trait; +use crate::{ + authentication, + error, +}; +use crate::traits::{ + client, + endpoint, + Request, + Schema, +}; + +pub struct Public { + client: reqwest::Client, + base: url::Url, +} + +pub struct Private { + public: Public, + tokens: tokio::sync::RwLock, +} + +impl Private { + async fn current_token(&self) -> authentication::Token { + let tokens = self.tokens.read().await; + let token: &authentication::Token = (&*tokens).into(); + token.clone() + } + + async fn refresh_tokens(&self) -> Result> { + let mut tokens = self.tokens.write().await; + *tokens = (*tokens).refresh(self).await?; + let token: &authentication::Token = (&*tokens).into(); + Ok(token.clone()) + } +} + +pub type Client = Private; + + +type AuthorizedError, R: Request> = error::api::Private; +type UnauthorizedError, R: Request> = error::api::Public; + +async fn authorized(client: &reqwest::Client, method: reqwest::Method, base: &url::Url, path: &str, request: &R, token: &authentication::Token) -> Result> +where + R: Request + Sync, + S: Schema, +{ + let url = base.join(path).map_err(AuthorizedError::::Url)?; + + let response = client.request(method, url) + .json(request) + .bearer_auth(token.as_ref()) + .send() + .await + .map_err(AuthorizedError::::Send)?; + + let body = match response.status() { + _ => response.text_with_charset("utf-8") + .await + .map_err(AuthorizedError::::Receive)?, + }; + + S::deserialize(request, &body).map_err(AuthorizedError::::Decode) +} + +async fn unauthorized(client: &reqwest::Client, method: reqwest::Method, base: &url::Url, path: &str, request: &R) -> Result> +where + R: Request + Sync, + S: Schema, +{ + let url = base.join(path).map_err(UnauthorizedError::::Url)?; + + let response = client.request(method, url) + .json(request) + .send() + .await + .map_err(UnauthorizedError::::Send)?; + + let body = match response.status() { + _ => response.text_with_charset("utf-8") + .await + .map_err(UnauthorizedError::::Receive)?, + }; + + S::deserialize(request, &body).map_err(UnauthorizedError::::Decode) +} + +#[async_trait] +impl client::Public for Public { + type Error = reqwest::Error; + + async fn execute(&self, endpoint: &E, request: &R) -> Result>::Error>> + where + E: endpoint::Public + Sync, + R: Request + Sync, + { + unauthorized::(&self.client, E::METHOD.into(), &self.base, endpoint.path(request), &request).await + } +} + +#[async_trait] +impl client::Public for Private { + type Error = reqwest::Error; + + async fn execute(&self, endpoint: &E, request: &R) -> Result>::Error>> + where + E: endpoint::Public + Sync, + R: Request + Sync, + { + self.public.execute::(endpoint, request).await + } +} + +#[async_trait] +impl client::Private for Private { + type Error = reqwest::Error; + + async fn execute(&self, endpoint: &E, request: &R) -> Result>::Error>> + where + E: endpoint::Private + Sync, + R: Request + Sync, + { + let token = self.current_token().await; + match authorized::(&self.public.client, E::METHOD.into(), &self.public.base, endpoint.path(request), &request, &token).await { + Err(AuthorizedError::::Unauthorized) if token.expired() => { + let token = self.refresh_tokens().await.map_err(AuthorizedError::::Refresh)?; + authorized::(&self.public.client, E::METHOD.into(), &self.public.base, endpoint.path(request), &request, &token).await + }, + result => result, + } + } +} diff --git a/api/src/reqwest/mod.rs b/api/src/reqwest/mod.rs new file mode 100644 index 0000000..8b3f738 --- /dev/null +++ b/api/src/reqwest/mod.rs @@ -0,0 +1,250 @@ +use crate::Method; +pub use reqwest; + +impl From for reqwest::Method { + fn from(method: Method) -> Self { + match method { + Method::GET => reqwest::Method::GET, + Method::POST => reqwest::Method::POST, + } + } +} +use crate::traits::{Request, Schema, client, endpoint}; +use crate::{authentication, error}; +use async_trait::async_trait; + +#[derive(Debug, Clone)] +pub struct Public { + client: reqwest::Client, + base: url::Url, +} + +impl Public { + pub fn new() -> Result { + let base = url::Url::parse("https://api.spond.com").unwrap(); + Self::new_with_base(base) + } + + pub fn new_with_base(base: url::Url) -> Result { + let client = reqwest::Client::builder() + .https_only(true) + .redirect(reqwest::redirect::Policy::limited(1)); + #[cfg(feature = "cookies")] + let client = client.cookie_store(true); + #[cfg(feature = "tracing")] + let client = client.connection_verbose(true); + + let client = client + //.user_agent("...") + //.read_timeout(std::time::Duration) + //.connect_timeout(std::time::Duration) + .build()?; + Ok(Self { client, base }) + } +} + +#[async_trait] +impl client::Authenticator for Public { + type Private = Private; + + fn with_tokens(&self, tokens: authentication::Tokens) -> Self::Private { + Private { + public: self.clone(), + tokens: tokio::sync::RwLock::new(tokens), + } + } +} + +#[derive(Debug)] +pub struct Private { + public: Public, + tokens: tokio::sync::RwLock, +} + +impl Private { + async fn current_token(&self) -> authentication::token::Access { + let tokens = self.tokens.read().await; + tokens.access_token.clone() + } + + async fn refresh_tokens( + &self, + ) -> Result> { + use client::Public; + let mut tokens = self.tokens.write().await; + *tokens = self + .public + .execute(&tokens.refresh_token, &tokens.refresh_token) + .await?; + Ok((*tokens).access_token.clone()) + } +} + +pub type Client = Private; + +type AuthorizedError = error::api::Private>::Error>; +type UnauthorizedError = error::api::Public>::Error>; + +#[tracing::instrument] +async fn authorized( + client: &reqwest::Client, + method: reqwest::Method, + base: &url::Url, + path: &str, + request: &R, + token: &authentication::token::Access, +) -> Result> +where + R: Request + Sync, + S: Schema, +{ + let url = base.join(path).map_err(AuthorizedError::::Url)?; + + let builder = client + .request(method, url) + .json(request) + .bearer_auth(token.as_ref()); + tracing::debug!("request: {builder:?}"); + + let response = builder + .send() + .await + .map_err(AuthorizedError::::Send)?; + tracing::debug!("response: {response:?}"); + + let body = match response.status() { + _ => response + .bytes() + .await + .map_err(AuthorizedError::::Receive)?, + }; + tracing::debug!("body: {body:?}"); + + let result = S::deserialize(request, &body).map_err(AuthorizedError::::Decode)?; + tracing::debug!("result: {result:?}"); + + Ok(result) +} + +#[tracing::instrument] +async fn unauthorized( + client: &reqwest::Client, + method: reqwest::Method, + base: &url::Url, + path: &str, + request: &R, +) -> Result> +where + R: Request + Sync, + S: Schema, +{ + let url = base.join(path).map_err(UnauthorizedError::::Url)?; + + let builder = client + .request(method, url) + .json(request); + tracing::debug!("request: {builder:?}"); + let response = builder + .send() + .await + .map_err(UnauthorizedError::::Send)?; + tracing::debug!("response: {response:?}"); + + let body = match response.status() { + _ => response + .bytes() + .await + .map_err(UnauthorizedError::::Receive)?, + }; + tracing::debug!("body: {body:?}"); + + let result = S::deserialize(request, &body).map_err(UnauthorizedError::::Decode)?; + tracing::debug!("result: {result:?}"); + + Ok(result) +} + +#[async_trait] +impl client::Public for Public { + type Error = reqwest::Error; + + async fn execute( + &self, + endpoint: &E, + request: &R, + ) -> Result>::Error>> + where + E: endpoint::Public + Sync, + R: Request + Sync, + { + unauthorized::( + &self.client, + E::METHOD.into(), + &self.base, + endpoint.path(request), + &request, + ) + .await + } +} + +#[async_trait] +impl client::Public for Private { + type Error = reqwest::Error; + + async fn execute( + &self, + endpoint: &E, + request: &R, + ) -> Result>::Error>> + where + E: endpoint::Public + Sync, + R: Request + Sync, + { + self.public.execute::(endpoint, request).await + } +} + +#[async_trait] +impl client::Private for Private { + type Error = reqwest::Error; + + async fn execute( + &self, + endpoint: &E, + request: &R, + ) -> Result>::Error>> + where + E: endpoint::Private + Sync, + R: Request + Sync, + { + let token = self.current_token().await; + match authorized::( + &self.public.client, + E::METHOD.into(), + &self.public.base, + endpoint.path(request), + &request, + &token, + ) + .await + { + Err(AuthorizedError::::Unauthorized) if token.expired() => { + let token = self + .refresh_tokens() + .await + .map_err(AuthorizedError::::Refresh)?; + authorized::( + &self.public.client, + E::METHOD.into(), + &self.public.base, + endpoint.path(request), + &request, + &token, + ) + .await + } + result => result, + } + } +} diff --git a/api/src/schema/mod.rs b/api/src/schema/mod.rs new file mode 100644 index 0000000..29fe093 --- /dev/null +++ b/api/src/schema/mod.rs @@ -0,0 +1 @@ +pub mod sponds; diff --git a/api/src/schema/sponds.rs b/api/src/schema/sponds.rs new file mode 100644 index 0000000..ee2c814 --- /dev/null +++ b/api/src/schema/sponds.rs @@ -0,0 +1,57 @@ +// TODO: use crate::Id; +use crate::traits; + +// { +// "heading" : "Kraftraum putzen", +// "id" : "D678340FAA6341058E368AE2FB6082CA", +// "series" : false, +// "startTime" : "2026-11-07T08:00:00Z", +// "unanswered" : true, +// "updated" : 1770872490567 +// } +#[derive(serde::Deserialize, Debug)] +pub struct Spond { + pub id: crate::utils::X128, + pub updated: crate::utils::Timestamp, + pub start_time: chrono::DateTime, + pub heading: String, + #[serde(default)] + pub unanswered: bool, + pub series: bool, +} + +#[derive(serde::Deserialize, Debug, Default)] +pub struct Sponds(Vec); + +impl std::ops::Deref for Sponds { + type Target = [Spond]; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +#[derive(serde::Serialize, Debug)] +pub struct Upcoming; + +impl traits::endpoint::Private for Sponds { + const METHOD: crate::Method = crate::Method::GET; + type Schema = Self; + + fn path(&self, _: &Upcoming) -> &str { + "/core/v1/sponds/upcoming" + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn decode_upcoming_schema() { + const DATA: &[u8] = include_bytes!("./sponds_upcoming.json"); + let bytes = bytes::Bytes::from_static(DATA); + let v: Sponds = >::deserialize(&Upcoming, &bytes).expect("VALID JSON"); + println!("{v:?}"); + } +} diff --git a/api/src/schema/sponds_upcoming.json b/api/src/schema/sponds_upcoming.json new file mode 100644 index 0000000..2787f86 --- /dev/null +++ b/api/src/schema/sponds_upcoming.json @@ -0,0 +1 @@ +[{"id":"AD033E0F90EF4A0E889C3E0EE4F7AACD","updated":1771395198239,"startTime":"2026-02-18T18:00:00Z","heading":"Abteilungsversammlung","series":false},{"id":"65CC28113E724113B1CE9AEC2BBF153E","updated":1771280224611,"startTime":"2026-02-19T13:00:00Z","heading":"Test","series":false},{"id":"5737EB7C021F498E878F14F4A9B39E63","updated":1771368685416,"startTime":"2026-02-19T18:45:00Z","heading":"Krafttraining Donnerstag","unanswered":true,"series":true},{"id":"81B37D845FB944E8A2652A8D425DB83E","updated":1771368696319,"startTime":"2026-02-20T17:30:00Z","heading":"Krafttraining Freitag","unanswered":true,"series":true},{"id":"0FD94BC6EE5243968BA068277DDAF5B1","updated":1771399515512,"startTime":"2026-02-21T10:45:00Z","heading":"Schwimmtraining Samstag","unanswered":true,"series":true},{"id":"4E6B81B750A34896AAD681E66A477AE4","updated":1770822214509,"startTime":"2026-02-22T09:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"94F4351412E14788B1CE8020A43E22AE","updated":1771341718834,"startTime":"2026-02-22T17:25:00Z","heading":"Athletik-Training","unanswered":true,"series":true},{"id":"E1D9A6C5C1554070BA592C2752270906","updated":1770872493135,"startTime":"2026-02-23T18:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"AC4C0EDD66FE4C29A66E6F637B5EF7AB","updated":1770872492350,"startTime":"2026-02-24T16:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"333BDC3E6DC04897B79334C887865DB1","updated":1770872490703,"startTime":"2026-02-25T18:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"CFB8D04583DA4F05977ABAB63821570E","updated":1770896398600,"startTime":"2026-02-26T18:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"D621B290A9B74F4CB5FFD4950F6EEBA4","updated":1770872491371,"startTime":"2026-02-26T18:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"547699FCE1944010A67A707399AE2A89","updated":1770872492706,"startTime":"2026-02-27T17:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"E06314BDF7804A9C83B6EE4E01DD4831","updated":1770809084109,"startTime":"2026-02-28T10:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"5360D7D37ED74F2D904B71BD4DA55B1F","updated":1770872492022,"startTime":"2026-03-01T09:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"16A8E790B9324173B57819E7687DC19E","updated":1770872491695,"startTime":"2026-03-01T17:25:00Z","heading":"Athletik-Training","series":true},{"id":"4D9928E94A0445CB8A29510BC619890C","updated":1770872493135,"startTime":"2026-03-02T18:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"6A99A0909F2346C796B14A011C613930","updated":1770872492350,"startTime":"2026-03-03T16:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"200FC5E4DCAB472EB96547CF468AC51E","updated":1770872490703,"startTime":"2026-03-04T18:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"25F4F0277E234C6BAE706A6828356D33","updated":1770896398600,"startTime":"2026-03-05T18:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"76416FBD18A4480E8FD8D0A09FE2F894","updated":1770872491371,"startTime":"2026-03-05T18:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"B67A85BEFCBB43BCB02E4A2B8E8BC5EE","updated":1770872492706,"startTime":"2026-03-06T17:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"E555E5F9355B429498E2650F409CDD4A","updated":1770571414141,"startTime":"2026-03-07T10:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"9628DFD73A0944C59819A5178AF5F912","updated":1770872492022,"startTime":"2026-03-08T09:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"44DDB2ACA9554DD89DD41F1EDF0EF7D4","updated":1770872491695,"startTime":"2026-03-08T17:25:00Z","heading":"Athletik-Training","series":true},{"id":"2E7E5A07FF4946F2AD0588922E39A966","updated":1770872493135,"startTime":"2026-03-09T18:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"6FE61FCEADBC40028CE048E78A38503B","updated":1770872492350,"startTime":"2026-03-10T16:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"CF0AA0DD1C0A43D681EEC7175F0B6030","updated":1770872490703,"startTime":"2026-03-11T18:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"E41A8DC5976E44CDBB944ABFABB939CF","updated":1770896398600,"startTime":"2026-03-12T18:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"F131CD46F80A42B9909D8E7F4018D8E1","updated":1770872491371,"startTime":"2026-03-12T18:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"A06ADBDC5FE547EA90B90A6886BF8FDF","updated":1770872492706,"startTime":"2026-03-13T17:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"2EF37B808AAE4C6AB0E053E31F381A75","updated":1770809084109,"startTime":"2026-03-14T10:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"FE0B1F8BC436438DA95E8F22A8FE6E61","updated":1770872492022,"startTime":"2026-03-15T09:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"CF6FEAE6EB14471184D5831945455005","updated":1770872491695,"startTime":"2026-03-15T17:25:00Z","heading":"Athletik-Training","series":true},{"id":"41AB8F2F49D54878A596268E3131D5F4","updated":1770872493135,"startTime":"2026-03-16T18:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"2590B6BFAFEF43E58C8040A127D5D119","updated":1770872492350,"startTime":"2026-03-17T16:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"922D71BF46F142CCAFEEE3933367ECD0","updated":1770872490703,"startTime":"2026-03-18T18:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"9E9960878AF847D08453E6618FCD1DE8","updated":1770896398600,"startTime":"2026-03-19T18:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"C3A14D8B724841079CD4AF2BEEBF452B","updated":1770872491371,"startTime":"2026-03-19T18:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"C43851BAF8914794935D0548BA7AF60D","updated":1770872492706,"startTime":"2026-03-20T17:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"AC95CBE05E8A4EB3BCCD8F4A180BA7FC","updated":1770809084109,"startTime":"2026-03-21T10:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"315A7320E90B493299341E5FBC4E3704","updated":1770872489876,"startTime":"2026-03-21T11:00:00Z","heading":"WK Run: Erlanger Winterwaldlauf","unanswered":true,"series":false},{"id":"7623A15FBB7C42F79A113F4428BC95D3","updated":1770872492022,"startTime":"2026-03-22T09:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"420B2D3BCB9548DCB80FBAFDD13ED962","updated":1770872491695,"startTime":"2026-03-22T17:25:00Z","heading":"Athletik-Training","series":true},{"id":"0CA6E6E0EB65442F89641D2EE895CE09","updated":1770872493135,"startTime":"2026-03-23T18:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"42064DCFCA4B49E98F9614AB3C7AABD0","updated":1770872492350,"startTime":"2026-03-24T16:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"1D49ABF2ED8D4C139675673800C62995","updated":1770872490703,"startTime":"2026-03-25T18:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"77346DC63E7B47FAA0328039F724B78F","updated":1770896398600,"startTime":"2026-03-26T18:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"6D23D3D0E9F2462180417BCA21E873CE","updated":1770872491371,"startTime":"2026-03-26T18:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"BB1F770E56954C4289213A09444DB76C","updated":1770872492706,"startTime":"2026-03-27T17:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"F0A208D28BF6436F87543E6324E58FC7","updated":1770809084109,"startTime":"2026-03-28T10:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"16FC02765C124B4EB950BA84D0C10069","updated":1770872492022,"startTime":"2026-03-29T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"1410B75032484CF19E676C894C128B85","updated":1770872491695,"startTime":"2026-03-29T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"F8A7A4616D154897AA7BD0F9C78C62FA","updated":1770872493135,"startTime":"2026-03-30T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"3A9517F2FD80451F9E2DE185FF887DC6","updated":1770872492350,"startTime":"2026-03-31T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"BE005E971955419B872333C538A819D8","updated":1770872490703,"startTime":"2026-04-01T17:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"318130BCC9E6404BB90123E731F04808","updated":1770896398600,"startTime":"2026-04-02T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"41A78760E3C949379E6E8C786A4B4574","updated":1770872491371,"startTime":"2026-04-02T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"87538464E4AD4AE29D8E6A4E8FD01C8E","updated":1770872492706,"startTime":"2026-04-03T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"6EE6269B5A204CC0AE2B6A04732D4775","updated":1770809084109,"startTime":"2026-04-04T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"B6DDBD0298A0449783DFD2AE956A3D26","updated":1770872492022,"startTime":"2026-04-05T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"FAB6FA8FB7554EC184B020001ADD8B94","updated":1770872491695,"startTime":"2026-04-05T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"E4424B8088D54FD38A9D18B1F0BDD3EC","updated":1770872493135,"startTime":"2026-04-06T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"A465565A012F4B3D8F0A723A3FEFCAA3","updated":1770872492350,"startTime":"2026-04-07T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"F142A604C9894396B10F22CAA01F8D7B","updated":1770872490703,"startTime":"2026-04-08T17:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"8EFED442D9444478A375DCFDBAFF0BDA","updated":1770896398600,"startTime":"2026-04-09T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"C27D9930301F4CC8B01CD8180BE0E10E","updated":1770872491371,"startTime":"2026-04-09T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"EE93FA9F675D401285AE2B501C31AED5","updated":1770872492706,"startTime":"2026-04-10T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"F94829E35A9B4A48A042646C8B658B01","updated":1770809084109,"startTime":"2026-04-11T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"4CA9B19A86204C2B8B47C469A4C54504","updated":1770872489114,"startTime":"2026-04-12T05:00:00Z","heading":"WK Run: Obermain-Marathon Bad Staffelstein","unanswered":true,"series":false},{"id":"2DB79CCDC3024429927D949DA45CCBE7","updated":1770872492022,"startTime":"2026-04-12T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"D194BD466EE74247A10BC41CE9094CB0","updated":1770872491695,"startTime":"2026-04-12T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"A141E76AA03345B3B32ED01FC602DEEA","updated":1770872493135,"startTime":"2026-04-13T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"274FE98580DD413FB58E784DD3BD99B5","updated":1770872492350,"startTime":"2026-04-14T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"731D5094989147659BC937327B235FE7","updated":1770872490703,"startTime":"2026-04-15T17:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"D52B3730DD404254BE7B517640ED174E","updated":1770896398600,"startTime":"2026-04-16T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"C389610AC9BF4970A3AFBB36431FE585","updated":1770872491371,"startTime":"2026-04-16T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"FEA2E4FFC9E6452EAB7B289223724EC5","updated":1770872492706,"startTime":"2026-04-17T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"950F44DE301F4A548F541B0FE5ED399F","updated":1770809084109,"startTime":"2026-04-18T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"79A681BC733A477A88794B26A9D0093E","updated":1770872492022,"startTime":"2026-04-19T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"D9310DC4BA274B6B90EBDF9D1E1F998F","updated":1770872491695,"startTime":"2026-04-19T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"53243D99E9824746B6C32711AF5B6900","updated":1770872493135,"startTime":"2026-04-20T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"47C16959F4774D3A8B36F9ECB42EE843","updated":1770872492350,"startTime":"2026-04-21T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"B3E387563B0745DEA0F720F3F26D66F6","updated":1770872490703,"startTime":"2026-04-22T17:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"07B9D6739D0B481EB7219F12461F3AC4","updated":1770896398600,"startTime":"2026-04-23T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"739F2147F8F7454CA339B14F7F9664E1","updated":1770872491371,"startTime":"2026-04-23T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"349B839EB9464198B62535EBC758E2FF","updated":1770872492706,"startTime":"2026-04-24T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"086E679C1E0B41F29025308C33B10B41","updated":1770809084109,"startTime":"2026-04-25T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"B15B6E51DD2749FCA773841632E66129","updated":1771358967671,"startTime":"2026-04-25T15:00:00Z","heading":"WK Swim & Run: Forcheim","unanswered":true,"series":false},{"id":"0E69CE6CFDE14A3DAB54E9CA9CA17469","updated":1770872492022,"startTime":"2026-04-26T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"62ED6865F64A4AD0BF5C8F5DCB236B4D","updated":1770872491695,"startTime":"2026-04-26T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"3BBC799F72094D809B5F08111449AA6D","updated":1770872493135,"startTime":"2026-04-27T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"564E309B351F4084BA75C19CEE97869C","updated":1770872492350,"startTime":"2026-04-28T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"FC025A3D356F4E2D8BA00F4A8C958F58","updated":1770872490703,"startTime":"2026-04-29T17:25:00Z","heading":"Virtual Bike Training (ictrainer)","series":true},{"id":"6FA76E8266B141AB9A2668749132240C","updated":1770896398600,"startTime":"2026-04-30T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"4003D5F0A3504F93BE84AAC86CD9973A","updated":1770872491371,"startTime":"2026-04-30T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"27A1A2E7F78E427295E26B2A83658B2E","updated":1770872489399,"startTime":"2026-05-01T06:00:00Z","heading":"WK Bike: Eschborn-Frankfurt","unanswered":true,"series":false},{"id":"9710E49CF5454A139B47D577A0219984","updated":1770872492706,"startTime":"2026-05-01T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"8B2233B360524F7695B64148E432C68F","updated":1770809084109,"startTime":"2026-05-02T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"33C43197140F4E009549B7339278C2D2","updated":1770872492022,"startTime":"2026-05-03T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"8F1843E801E544F4822F7F92AAA822DF","updated":1770872491695,"startTime":"2026-05-03T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"3D3F7931216E46D69FED303DB3DAECE3","updated":1770872493135,"startTime":"2026-05-04T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"CB9DB4AE1C684E9CA419798C2380D964","updated":1770872492350,"startTime":"2026-05-05T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"0298D709FE364907BB99E9F370D528BE","updated":1770896398600,"startTime":"2026-05-07T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"B25FE6D86FE241EF8CDBFEA9A1CCFDD2","updated":1770872491371,"startTime":"2026-05-07T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"403CA787543F4A83ABD9A23FC3A32F46","updated":1770872492706,"startTime":"2026-05-08T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"8DD4409556DE4F108A5179C436A00C34","updated":1770872489612,"startTime":"2026-05-09T04:00:00Z","heading":"WK Tri: Weiden Triathlon","unanswered":true,"series":false},{"id":"8180BAAD76A24DC2B94D4394CF21BD58","updated":1770809084109,"startTime":"2026-05-09T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"7AF03606CF784532A080EF75718517F3","updated":1770872492022,"startTime":"2026-05-10T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"369E46341FAD44189558D1CA369A2D16","updated":1770872491695,"startTime":"2026-05-10T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"14B080871B8541A4AB7F6B05D698D9E4","updated":1770872493135,"startTime":"2026-05-11T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"CEFAEB27108548C08BDFAEC83B192086","updated":1770872492350,"startTime":"2026-05-12T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"9486F14CB6F9474F850465A13D84B1EC","updated":1770896398600,"startTime":"2026-05-14T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"DCDA1DA4197844B8BEFDCA921BC3FD27","updated":1770872491371,"startTime":"2026-05-14T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"A3A3A0C1C8B544C580993B3E4E53AF40","updated":1770872492706,"startTime":"2026-05-15T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"FC1C7372F16B4893942EB5910DA60C0F","updated":1770809084109,"startTime":"2026-05-16T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"5B35D8E10EFB4A34B6BE08C463CE3842","updated":1770872490042,"startTime":"2026-05-17T05:00:00Z","heading":"WK Tri: Schweinfurt MainCityTriathlon","unanswered":true,"series":false},{"id":"2DAA54C83EB54DF6B09FB09E4BC53244","updated":1770872492022,"startTime":"2026-05-17T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"6E2047A76DDB4B9188DDDC1A046FB2BC","updated":1770872491695,"startTime":"2026-05-17T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"DF4F4BA284604010A11EA7CAF81ECFF1","updated":1770872493135,"startTime":"2026-05-18T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"2171B4D900134E729F13289C3C4FE0C8","updated":1770872492350,"startTime":"2026-05-19T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"62E1A57B3938448DA6561B2242ED5668","updated":1770896398600,"startTime":"2026-05-21T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"AA9279C8100F4BD49D39274BD5A1AD12","updated":1770872491371,"startTime":"2026-05-21T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"F05A75CA3B294EABB4E3526C0A02DED2","updated":1770872492706,"startTime":"2026-05-22T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"88312F5063ED4F3AA07323F3D22F5E16","updated":1770809084109,"startTime":"2026-05-23T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"A4334CCDF2B040118297049C0D882235","updated":1770872492022,"startTime":"2026-05-24T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"128FF4E69E2D46FE9E31EF95AC276612","updated":1770872491695,"startTime":"2026-05-24T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"BDAC8DB396E148769A2468CCFC617E1D","updated":1770872493135,"startTime":"2026-05-25T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"900BE134E7CA4DEBB885F78348DF38CE","updated":1770872492350,"startTime":"2026-05-26T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"F8D90B5CD38744869FA539B6ED83D725","updated":1770896398600,"startTime":"2026-05-28T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"E79BF9D5E88A4075A26CD78A72BCC268","updated":1770872491371,"startTime":"2026-05-28T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"7FAD5D73F82341E988BA71A818EBDEC3","updated":1770872492706,"startTime":"2026-05-29T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"91B7AEEE784D4492900518284FF45255","updated":1770809084109,"startTime":"2026-05-30T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"83CEFA07B61D4D2C8905B47F9017A3A2","updated":1770872492022,"startTime":"2026-05-31T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"DBD8EC4F7ED64608AC1F4250DCCF62E1","updated":1770872491695,"startTime":"2026-05-31T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"AA55DF652913416D9C2698BA29EA694D","updated":1770872493135,"startTime":"2026-06-01T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"0DC10A25F7FC4C2FA58CAE3D50300D4C","updated":1770872492350,"startTime":"2026-06-02T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"2F7021C8234C4C4B8B6B1B85E7572DDD","updated":1770896398600,"startTime":"2026-06-04T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"517C2489DFAD4D3090A95826E6768A92","updated":1770872491371,"startTime":"2026-06-04T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"1C131C2950DB481C93A9E19322BE1630","updated":1770872492706,"startTime":"2026-06-05T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"DE3D3C652E9848C8ADAE0B6DDFFA522E","updated":1770809084109,"startTime":"2026-06-06T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"DDB1D0E25E8844A59A52DB00884C48A7","updated":1770872489185,"startTime":"2026-06-07T04:00:00Z","heading":"WK Tri: Ironman Hamburg","unanswered":true,"series":false},{"id":"58D55ABC265F4D2EBA0D56A9F38EB866","updated":1770872492022,"startTime":"2026-06-07T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"F7B66F6E50A145AA92DD4534C956A5CB","updated":1771358975548,"startTime":"2026-06-07T11:00:00Z","heading":"WK Tri: Bamberg Rattelsdorf-Ebing","unanswered":true,"series":false},{"id":"48FA244668A94754B088CF6FD833BC08","updated":1770872491695,"startTime":"2026-06-07T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"FB7F2D0E11E04775BDF3A8C128982FB7","updated":1770872493135,"startTime":"2026-06-08T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"5758BB1344984CDDB352356E12CCC00D","updated":1770872492350,"startTime":"2026-06-09T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"CB9D20D975D34D6EA5FBAD22309F48B2","updated":1770896398600,"startTime":"2026-06-11T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"62F6322CD41D45EABBA83E35DE93CBEA","updated":1770872491371,"startTime":"2026-06-11T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"8F57067F3B9F47DF8DF8C6C14F806758","updated":1770872492706,"startTime":"2026-06-12T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"4D5F35EAEC2441DCA2CDEFF1059A50FA","updated":1770809084109,"startTime":"2026-06-13T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"B8B6CF361F9A498C8BE6084A0C9EB0A4","updated":1770872489824,"startTime":"2026-06-13T11:00:00Z","heading":"WK Tri: Kallmünzer Triathlon","unanswered":true,"series":false},{"id":"DF952E9C2CE64830AD852C00874A51C2","updated":1770872489346,"startTime":"2026-06-14T05:00:00Z","heading":"WK Tri: Forcheim Triathlon","unanswered":true,"series":false},{"id":"EE7E37CB7555435DA37155ED2F2413F0","updated":1770872490149,"startTime":"2026-06-14T06:00:00Z","heading":"WK Tri: Ingolstadt Triathlon","unanswered":true,"series":false},{"id":"57F40409B2A54888A199B05B89E45915","updated":1770872492022,"startTime":"2026-06-14T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"01ADB52C67794CA7BB6D69D26E67B2FC","updated":1770872491695,"startTime":"2026-06-14T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"E57918F0FC134E069FAA880C6BC573C8","updated":1770872493135,"startTime":"2026-06-15T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"863A72BCFCDE408BAE8A2DF82E78FEB1","updated":1770872492350,"startTime":"2026-06-16T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"3A2C5200466845EB91E3A0BBB4A8DBDF","updated":1770896398600,"startTime":"2026-06-18T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"41F1816B0FFE4778A518212D5DBC1756","updated":1770872491371,"startTime":"2026-06-18T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"0FD3581FF10C40D9BEAC883864AE8F54","updated":1770872492706,"startTime":"2026-06-19T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"B5C73942755A45C0A26735A74571B147","updated":1771358989948,"startTime":"2026-06-20T05:00:00Z","heading":"WK Tri: Rothsee Triathlon - Sprint & Schüler","unanswered":true,"series":false},{"id":"B665D8CAFDA84A4BA6417E19D4A5BBCF","updated":1770809084109,"startTime":"2026-06-20T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"E2AC39AA47D641BCA494EE5E1C2A6C9D","updated":1770872489559,"startTime":"2026-06-21T05:00:00Z","heading":"WK Tri: Rothsee Triathlon - Olympisch","unanswered":true,"series":false},{"id":"0F983EDD457D4078A83CABCDC225A382","updated":1770872492022,"startTime":"2026-06-21T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"0C0247F25D5B4EEAAB046320CD9E7708","updated":1770872491695,"startTime":"2026-06-21T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"089630E27C174208A09F2380CB90F9BE","updated":1770872493135,"startTime":"2026-06-22T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"98C437703DE5486E8E64E94FF7B612F9","updated":1770872492350,"startTime":"2026-06-23T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"CEF688E08CFD4ABBA64AAA43AD77B353","updated":1770896398600,"startTime":"2026-06-25T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"A39BE570AF754754AA7F7282404D69E7","updated":1770872491371,"startTime":"2026-06-25T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"DED0BB679FE444F0AB31BED51185E471","updated":1770872492706,"startTime":"2026-06-26T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"C3E50842A4AC4CB8B02ACF8E560CC3BE","updated":1770809084109,"startTime":"2026-06-27T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"6BCB8683D912404F8ABF5C5DEF377782","updated":1770872489982,"startTime":"2026-06-28T04:00:00Z","heading":"WK Tri: Ironman Frankfurt ","unanswered":true,"series":false},{"id":"1C828D56FC3C4726959545C9C3AFF9DE","updated":1771358981104,"startTime":"2026-06-28T05:00:00Z","heading":"WK Tri: Trebgast Triathlon","unanswered":true,"series":false},{"id":"19133B8E5DB440DF99139D8E7C90B986","updated":1771359005002,"startTime":"2026-06-28T06:00:00Z","heading":"WK Tri: Herzoman","unanswered":true,"series":false},{"id":"193F5C0D4518407CB9875D8FC23B11BF","updated":1770872492022,"startTime":"2026-06-28T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"AC7CDB68663849479CE411F70F0E50C8","updated":1770872491695,"startTime":"2026-06-28T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"2FE40255B00F4115B152AC69EF6AAA31","updated":1770872493135,"startTime":"2026-06-29T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"3C6EDD866CB143EFA92D16C67E879623","updated":1770872492350,"startTime":"2026-06-30T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"D15FC0223CE047E3AE3A978F17ED7BEF","updated":1770896398600,"startTime":"2026-07-02T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"D000D3A8DE074BFCB0BBAC0E39819038","updated":1770872491371,"startTime":"2026-07-02T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"7728A184DAE64011B18848BF9F956F8D","updated":1770872492706,"startTime":"2026-07-03T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"6236B4F4769647B39EBFDAE4112AB18B","updated":1770809084109,"startTime":"2026-07-04T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"0045063DCDAE4C879F67BFFD2643B51B","updated":1770872490199,"startTime":"2026-07-05T04:00:00Z","heading":"WK Tri: Challenge Roth","unanswered":true,"series":false},{"id":"E05E9905FBD048E693BEAD63D8072B7C","updated":1770872492022,"startTime":"2026-07-05T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"985E53EF1A0740D5A397E17473E2DA7B","updated":1770872491695,"startTime":"2026-07-05T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"85EFCF12E907492CB1C49BABB7A9F55C","updated":1770872493135,"startTime":"2026-07-06T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"8069A7E5221749B8B4C55592CDA72DE4","updated":1770872492350,"startTime":"2026-07-07T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"A3DF460077DD45E8AC2D3A2524BC590C","updated":1770896398600,"startTime":"2026-07-09T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"4C47FA4C6CB4445ABB79CD4D29D59BBA","updated":1770872491371,"startTime":"2026-07-09T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"2FF7145EFE4C4AA4BE393D5CF5930EAE","updated":1770872492706,"startTime":"2026-07-10T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"2FF4B87D66664B75AEB8FB2BC21923BD","updated":1770809084109,"startTime":"2026-07-11T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"1F812F83763D4566ABBC0AAD50994716","updated":1770872490463,"startTime":"2026-07-12T05:00:00Z","heading":"WK Tri: Hof Triathlon","unanswered":true,"series":false},{"id":"13B16D2193714DFDA30D45C829FF52EF","updated":1770872492022,"startTime":"2026-07-12T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"E2F769722C3B46E099D61710A589123C","updated":1770872491695,"startTime":"2026-07-12T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"62389FE9A5AA4049B07288DC2B32B848","updated":1770872493135,"startTime":"2026-07-13T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"91625CB3B14B429CB6EB88BE7FA09BF7","updated":1770872492350,"startTime":"2026-07-14T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"713614E7EBFB4B12B52297DC9DE4E9D8","updated":1770896398600,"startTime":"2026-07-16T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"F0E9D5686E5B4FFEAE958750558EC44F","updated":1770872491371,"startTime":"2026-07-16T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"8B950304FA5D49869901651C7D42FE00","updated":1770872492706,"startTime":"2026-07-17T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"8189C6AE2A18431491D32D6A90F13D66","updated":1770809084109,"startTime":"2026-07-18T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"493EC5E1B30F47E6BE94245A189856D8","updated":1770872492022,"startTime":"2026-07-19T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"E8EBD45D473E45738ED53C60CA621944","updated":1770872491695,"startTime":"2026-07-19T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"8F009AD5ECF14302A57F2D9611A0C63D","updated":1770872493135,"startTime":"2026-07-20T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"E87E3974791B4DCA8E9123ABB140AC72","updated":1770872492350,"startTime":"2026-07-21T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"2708F93B29ED49D8941B9C05D29A7D67","updated":1770896398600,"startTime":"2026-07-23T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"3700734186F044038474C2A600EEF4F3","updated":1770872491371,"startTime":"2026-07-23T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"0D0333358AD04C33908DE97DF042F019","updated":1770872492706,"startTime":"2026-07-24T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"3C48E9130D2140FA940BD32F6D86C55F","updated":1770809084109,"startTime":"2026-07-25T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"3597C7A9DFEE4D3990F4364CDBD48854","updated":1770872490251,"startTime":"2026-07-26T05:00:00Z","heading":"WK Tri: Erlanger Triathlon","unanswered":true,"series":false},{"id":"94D76E20515341299C16C2D5558E1294","updated":1770872492022,"startTime":"2026-07-26T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"48F4A73A24BB4746B8131688789DE579","updated":1770872491695,"startTime":"2026-07-26T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"608334E080854CCE840F6378A5CD84C2","updated":1770872493135,"startTime":"2026-07-27T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"2412DB8A6556427EB8BCE4F349E13037","updated":1770872492350,"startTime":"2026-07-28T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"462D25DFBC2F4384A679CDF8D5C0691B","updated":1770896398600,"startTime":"2026-07-30T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"2DBF2336730D43AAAC58E914837C5F0E","updated":1770872491371,"startTime":"2026-07-30T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"ACC91422FAD349F48557F287B27FBD51","updated":1770872492706,"startTime":"2026-07-31T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"FDAED0C615AD4E3BAA836247D37DE6AF","updated":1770809084109,"startTime":"2026-08-01T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"8CB986167D8B4E9F916BBF3C9DDBDB3C","updated":1770872492022,"startTime":"2026-08-02T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"7A1E9CA2F54C470D89ED3A18A02ADBBA","updated":1770872491695,"startTime":"2026-08-02T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"C9D25BB4931C4E4F90465370177ECE64","updated":1770872493135,"startTime":"2026-08-03T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"120B893E4D1E496698FDEF4074887968","updated":1770872492350,"startTime":"2026-08-04T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"F49DC332CF024F62B4B3E0A0A3488580","updated":1770896398600,"startTime":"2026-08-06T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"94677D04655144E985176DE32668457E","updated":1770872491371,"startTime":"2026-08-06T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"883E2D725D46422793D2A109908495E4","updated":1770872492706,"startTime":"2026-08-07T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"F4748051C0EA47F6B7EF8B63E75AFF3A","updated":1770809084109,"startTime":"2026-08-08T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"86171BB304DB48CBB5A390CA0A55A1ED","updated":1770872489291,"startTime":"2026-08-09T05:00:00Z","heading":"WK Tri: Nürnberg Triathlon","unanswered":true,"series":false},{"id":"FF6CEF5D64474351818A14271F7C1B46","updated":1770872492022,"startTime":"2026-08-09T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"C5BC881DDCA348DA833D9D484F0EEB39","updated":1770872491695,"startTime":"2026-08-09T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"BDC179CB3C764A2690B13E2058D3EEAF","updated":1770872493135,"startTime":"2026-08-10T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"368B2DC59B324FBFA79395A96A19DB75","updated":1770872492350,"startTime":"2026-08-11T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"B0DDD8947F464018BC8DD23055EAFBD7","updated":1770896398600,"startTime":"2026-08-13T17:45:00Z","heading":"Krafttraining Donnerstag","series":true},{"id":"DA28C1995394492CBD9BE0A6C30A09D7","updated":1770872491371,"startTime":"2026-08-13T17:55:00Z","heading":"Schwimmtraining Donnerstag","series":true},{"id":"83242F9071E34B34BE5005755F1920BF","updated":1770931780528,"startTime":"2026-08-14T16:30:00Z","heading":"Krafttraining Freitag","series":true},{"id":"341C5932BF674488B2790DB969B15504","updated":1770978099780,"startTime":"2026-08-15T09:45:00Z","heading":"Schwimmtraining Samstag","series":true},{"id":"AA88F8A874DA4775A61E029631BEE55D","updated":1771056456282,"startTime":"2026-08-16T08:00:00Z","heading":"MTB am Sonntag","series":true},{"id":"FA4BCD9A656A42C3BE01B80FF50D0EBE","updated":1771086954334,"startTime":"2026-08-16T16:25:00Z","heading":"Athletik-Training","series":true},{"id":"302E7BCFAF674BBCA0EE77B0D119158E","updated":1771196256828,"startTime":"2026-08-17T17:45:00Z","heading":"Schwimmtraining Montag","series":true},{"id":"C9E5B5C2D5694F82B1F3DB1BDC0B5CBD","updated":1771306178424,"startTime":"2026-08-18T15:55:00Z","heading":"Lauftraining Intervalle Dienstag","series":true},{"id":"16EA34002E0A4AA29548881CC3FF0FD5","updated":1770872489772,"startTime":"2026-08-23T05:00:00Z","heading":"WK Tri: Allgäu Triathlon","unanswered":true,"series":false},{"id":"7686681ADE904FAFAEF03D24BA225E4C","updated":1770872490305,"startTime":"2026-08-30T05:00:00Z","heading":"WK Tri: Brombachsee Triathlon","unanswered":true,"series":false},{"id":"888EA479199B4FF588BD8DCD1D5BBAFF","updated":1770872489508,"startTime":"2026-09-06T19:00:00Z","heading":"WK Run: Fränkische Schweiz-Marathon","unanswered":true,"series":false},{"id":"C3446FA49A39439AAFB63822C7117153","updated":1771359026096,"startTime":"2026-09-13T05:00:00Z","heading":"WK Tri: Seenland Triathlon","unanswered":true,"series":false},{"id":"2123C68846F94E4EAA30C2153124A231","updated":1770872489927,"startTime":"2026-09-20T08:00:00Z","heading":"WK Run: Tegernseelauf","unanswered":true,"series":false},{"id":"43C7F527BE1441C0A4CE29E566F49516","updated":1771359109568,"startTime":"2026-09-27T05:00:00Z","heading":"WK Run: Marathon Berlin","unanswered":true,"series":false},{"id":"263B93B766824638A85128ED22D3FB98","updated":1770872490514,"startTime":"2026-10-11T05:00:00Z","heading":"WK Run: München Marathon","unanswered":true,"series":false},{"id":"D678340FAA6341058E368AE2FB6082CA","updated":1770872490567,"startTime":"2026-11-07T08:00:00Z","heading":"Kraftraum putzen","unanswered":true,"series":false}] diff --git a/api/src/traits/authentication/login.rs b/api/src/traits/authentication/login.rs new file mode 100644 index 0000000..15c6559 --- /dev/null +++ b/api/src/traits/authentication/login.rs @@ -0,0 +1 @@ +pub trait Credentials: super::super::Request {} diff --git a/api/src/traits/authentication/mod.rs b/api/src/traits/authentication/mod.rs new file mode 100644 index 0000000..d86da16 --- /dev/null +++ b/api/src/traits/authentication/mod.rs @@ -0,0 +1,2 @@ +pub mod login; +pub use login::Credentials; diff --git a/api/src/traits/authorization.rs b/api/src/traits/authorization.rs new file mode 100644 index 0000000..30aa41b --- /dev/null +++ b/api/src/traits/authorization.rs @@ -0,0 +1,11 @@ +pub trait Authorization: private::Seal {} + +mod private { + use crate::authorization::{False, True}; + pub trait Seal {} + + impl Seal for True {} + impl Seal for False {} +} + +impl Authorization for T {} diff --git a/api/src/traits/client.rs b/api/src/traits/client.rs new file mode 100644 index 0000000..e27b561 --- /dev/null +++ b/api/src/traits/client.rs @@ -0,0 +1,80 @@ +use super::{Authorization, Endpoint, Request, Schema, endpoint}; +use crate::{authorization, authentication, error}; +use async_trait::async_trait; + +pub trait Client: Public + Private {} + +impl Client for C {} + +#[async_trait] +pub trait Handler, R: Request, A: Authorization> { + type Error: std::error::Error; + + async fn execute(&self, endpoint: &E, request: &R) -> Result; +} + +#[async_trait] +pub trait Authenticator: Public { + type Private: Private; + + fn with_tokens(&self, tokens: authentication::Tokens) -> Self::Private; + + async fn authenticate(&self, endpoint: &E, request: &R) -> Result::Error, >::Error>> + where + E: endpoint::Public + Sync, + R: Request + Sync, + { + let tokens = self.execute(endpoint, request).await?; + Ok(self.with_tokens(tokens)) + } +} + +#[async_trait] +pub trait Public { + type Error: std::error::Error + Send; + + async fn execute( + &self, + endpoint: &E, + request: &R, + ) -> Result>::Error>> + where + E: endpoint::Public + Sync, + R: Request + Sync; +} + +#[async_trait] +impl + Sync, R: Request + Sync> + Handler for P +{ + type Error = error::api::Public>::Error>; + + async fn execute(&self, endpoint: &E, request: &R) -> Result { + self.execute(endpoint, request).await + } +} + +#[async_trait] +pub trait Private { + type Error: std::error::Error + Send; + + async fn execute( + &self, + endpoint: &E, + request: &R, + ) -> Result>::Error>> + where + E: endpoint::Private + Sync, + R: Request + Sync; +} + +#[async_trait] +impl + Sync, R: Request + Sync> + Handler for P +{ + type Error = error::api::Private>::Error>; + + async fn execute(&self, endpoint: &E, request: &R) -> Result { + self.execute(endpoint, request).await + } +} diff --git a/api/src/traits/endpoint.rs b/api/src/traits/endpoint.rs new file mode 100644 index 0000000..d8aef19 --- /dev/null +++ b/api/src/traits/endpoint.rs @@ -0,0 +1,53 @@ +use super::{Authorization, Request, Schema}; +use crate::{Method, authorization}; + +pub trait Endpoint: private::Seal { + const METHOD: Method; + type Schema: Schema; + + fn path(&self, request: &R) -> &str; +} + +/// A Endpoint with required authorization +pub trait Private { + const METHOD: Method; + type Schema: Schema; + + fn path(&self, request: &R) -> &str; +} + +impl, R: Request> Endpoint for T { + const METHOD: Method = T::METHOD; + type Schema = T::Schema; + + fn path(&self, request: &R) -> &str { + self.path(request) + } +} + +/// A Endpoint without required authorization +pub trait Public { + const METHOD: Method; + type Schema: Schema; + + fn path(&self, request: &R) -> &str; +} + +impl, R: Request> Endpoint for T { + const METHOD: Method = T::METHOD; + type Schema = T::Schema; + + fn path(&self, request: &R) -> &str { + self.path(request) + } +} + +mod private { + use super::*; + + /// Seal the Endpoint dependency + pub trait Seal {} + + impl> Seal for P {} + impl> Seal for P {} +} diff --git a/api/src/traits/id.rs b/api/src/traits/id.rs new file mode 100644 index 0000000..956ac12 --- /dev/null +++ b/api/src/traits/id.rs @@ -0,0 +1,22 @@ +use super::{ + client::Handler, + Schema, + Endpoint, +}; +use crate::{ + Id, + authorization, +}; +use async_trait::async_trait; + +#[async_trait] +pub trait Marker: Schema> + Endpoint, authorization::True, Schema=Self> + std::fmt::Debug { + async fn resolve, authorization::True> + Sync>(&self, id: &Id, handler: &H) -> Result; +} + +#[async_trait] +impl> + Endpoint, authorization::True, Schema=T> + Sync + std::fmt::Debug> Marker for T { + async fn resolve, authorization::True> + Sync>(&self, id: &Id, handler: &H) -> Result { + handler.execute(&self, id).await + } +} diff --git a/api/src/traits/mod.rs b/api/src/traits/mod.rs new file mode 100644 index 0000000..93881d9 --- /dev/null +++ b/api/src/traits/mod.rs @@ -0,0 +1,17 @@ +pub mod authentication; +pub mod authorization; +pub mod client; +pub mod endpoint; +pub mod id; +pub mod request; +pub mod schema; + +pub use authentication::Credentials; +pub use authorization::Authorization; +pub use client::Client; +pub use endpoint::Endpoint; +pub use request::Request; +pub use schema::Schema; + +//#[cfg(test)] +//mod test; diff --git a/api/src/traits/request.rs b/api/src/traits/request.rs new file mode 100644 index 0000000..a7f8a19 --- /dev/null +++ b/api/src/traits/request.rs @@ -0,0 +1,5 @@ +use serde::Serialize; + +pub trait Request: Serialize + std::fmt::Debug {} + +impl Request for T {} diff --git a/api/src/traits/schema.rs b/api/src/traits/schema.rs new file mode 100644 index 0000000..1524861 --- /dev/null +++ b/api/src/traits/schema.rs @@ -0,0 +1,17 @@ +use super::Request; +use bytes::Bytes; +use serde::de::DeserializeOwned; + +pub trait Schema: std::fmt::Debug + Send + Sized { + type Error: std::error::Error + Send; + + fn deserialize(request: &R, response: &Bytes) -> Result; +} + +impl Schema for T { + type Error = serde_json::Error; + + fn deserialize(_: &R, response: &Bytes) -> Result { + serde_json::from_slice(&response) + } +} diff --git a/api/src/traits/test.rs b/api/src/traits/test.rs new file mode 100644 index 0000000..d13987c --- /dev/null +++ b/api/src/traits/test.rs @@ -0,0 +1,53 @@ +use async_trait::async_trait; + +struct Private; +struct Endpoint; +#[derive(serde::Serialize)] +struct Request; +#[derive(serde::Deserialize)] +struct Schema; + +#[async_trait] +impl super::client::Private for Private { + type Error = error::Private; + + async fn execute(&self, _: &E, _: &R) -> Result>::Error>> + where + E: super::endpoint::Private, + R: super::Request + Sync, + { + Err(error::Private::Unauthorized) + } +} + +impl super::endpoint::Private for Endpoint { + const METHOD: reqwest::Method = reqwest::Method::GET; + type Schema = Schema; + + fn path(&self, _: &Request) -> &str { + "/core/v1/endpoint/private" + } +} + +mod error { + use thiserror::Error; + + #[derive(Debug, Error)] + pub enum Private { + #[error("unauthorized")] + Unauthorized, + } +} + +#[tokio::test] +async fn private_endpoint() { + use super::client::Private; + let client = Private; + let request = Request; + let endpoint = Endpoint; + let result = match client.execute(&endpoint, &request).await { + Err(error::Private::Unauthorized) => false, + _ => true, + }; + assert_eq!(result, true) +} diff --git a/api/src/utils/mod.rs b/api/src/utils/mod.rs new file mode 100644 index 0000000..1e4bbdc --- /dev/null +++ b/api/src/utils/mod.rs @@ -0,0 +1,5 @@ +mod x128; +pub use x128::X128; + +mod timestamp; +pub use timestamp::Timestamp; diff --git a/api/src/utils/timestamp.rs b/api/src/utils/timestamp.rs new file mode 100644 index 0000000..097b5fe --- /dev/null +++ b/api/src/utils/timestamp.rs @@ -0,0 +1,2 @@ +#[derive(Debug, serde::Deserialize)] +pub struct Timestamp(u64); diff --git a/api/src/utils/x128.rs b/api/src/utils/x128.rs new file mode 100644 index 0000000..af6daef --- /dev/null +++ b/api/src/utils/x128.rs @@ -0,0 +1,78 @@ +use serde::{Serialize, Deserialize, Serializer, Deserializer}; +use std::ops::Deref; +use std::str::FromStr; +use std::fmt; + +/// Wrapper for u128 that serializes/deserializes as 32-charachter hex +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +pub struct X128(u128); + +#[derive(Debug, thiserror::Error)] +pub enum Error { + #[error("invalid length: {0}")] + Length(usize), + + #[error("parser error: {0}")] + Parser(#[from] std::num::ParseIntError), +} + +impl X128 { + /// construct a new value + pub fn new(value: u128) -> Self { + Self(value) + } + + /// access the inner value explicitely + pub fn value(&self) -> u128 { + self.0 + } +} + +impl FromStr for X128 { + type Err = Error; + + fn from_str(s: &str) -> Result { + match s.len() { + 32 => u128::from_str_radix(s, 16) + .map(Self::new) + .map_err(Error::Parser), + len => Err(Error::Length(len)), + } + } +} + +impl TryFrom<&str> for X128 { + type Error = Error; + + fn try_from(s: &str) -> Result { + Self::from_str(s) + } +} + +impl Deref for X128 { + type Target = u128; + + fn deref(&self) -> &u128 { + &self.0 + } +} + +impl fmt::Display for X128 { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:032x}", self.0) + } +} + +impl Serialize for X128 { + fn serialize(&self, serializer: S) -> Result { + serializer.serialize_str(&self.to_string()) + } +} + +impl<'de> Deserialize<'de> for X128 { + fn deserialize>(deserializer: D) -> Result { + let s = String::deserialize(deserializer)?; + + Self::from_str(&s).map_err(serde::de::Error::custom) + } +} diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..cad5b4b --- /dev/null +++ b/flake.lock @@ -0,0 +1,25 @@ +{ + "nodes": { + "nixpkgs": { + "locked": { + "lastModified": 1770843696, + "narHash": "sha256-LovWTGDwXhkfCOmbgLVA10bvsi/P8eDDpRudgk68HA8=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "2343bbb58f99267223bc2aac4fc9ea301a155a16", + "type": "github" + }, + "original": { + "id": "nixpkgs", + "type": "indirect" + } + }, + "root": { + "inputs": { + "nixpkgs": "nixpkgs" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..635f84f --- /dev/null +++ b/flake.nix @@ -0,0 +1,59 @@ +{ + outputs = { nixpkgs, ... }: let + spond = { rustPlatform, rustfmt, clippy, pkg-config, openssl, ... }: rustPlatform.buildRustPackage { + pname = "spond"; + version = "0.0.0"; + + src = ./.; + cargoLock.lockFile = ./Cargo.lock; + nativeBuildInputs = [ + pkg-config + ]; + propagatedBuildInputs = [ + openssl.dev + ]; + }; + + allpkgs = system: pkgs: pkgs.extend (_: _: nixpkgs.lib.attrsets.filterAttrs (name: _: name != "default") (packages system pkgs)); + + packages = system: pkgs': let + pkgs = allpkgs system pkgs'; + in { + default = pkgs.spond; + spond = pkgs.callPackage spond {}; + }; + + devShells = system: pkgs': let + pkgs = allpkgs system pkgs'; + in builtins.mapAttrs (devShell pkgs) (packages system pkgs'); + + devShell = pkgs: name: pkg: pkgs.mkShell { + buildInputs = with pkgs; [ + cargo + cargo-machete + cargo-workspaces + cargo-unused-features + cargo-udeps + cargo-audit + cargo-diet + cargo-duplicates + cargo-flamegraph + clippy + + (python3.withPackages (py: [ py.pyyaml ])) + + rustc + rustfmt + ] ++ pkg.buildInputs; + + nativeBuildInputs = pkg.nativeBuildInputs; + + shellHook = '' + printf 'Dev shell for %s ready!\n' '${pkg.name}' + ''; + }; + in { + packages = builtins.mapAttrs packages nixpkgs.legacyPackages; + devShells = builtins.mapAttrs devShells nixpkgs.legacyPackages; + }; +} diff --git a/turnerbund/:w b/turnerbund/:w new file mode 100644 index 0000000..4a1c242 --- /dev/null +++ b/turnerbund/:w @@ -0,0 +1,231 @@ +use tracing_subscriber::prelude::*; +use tracing_subscriber::{fmt, EnvFilter}; +pub use tracing::{error, warn, info, debug, trace}; + +#[cfg(feature="disabled")] +mod disabled { + +//mod select; +//use select::WeightedSet; +mod api; +mod utils; +mod id; +mod user; + +use tracing_subscriber::prelude::*; +use tracing_subscriber::{fmt, EnvFilter}; +pub use tracing::{error, warn, info, debug, trace}; + +use rand::prelude::*; +use std::collections::HashSet; +use std::collections::HashMap; + +#[derive(Debug, thiserror::Error)] +pub enum NoError {} + +#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)] +struct UserID(u128); + +impl std::fmt::Display for UserID { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "UserID({})", self.0) + } +} + +#[derive(Default)] +struct Participants(Vec<(UserID, usize)>); + +trait Event { + fn registered(&self, uid: UserID) -> bool; + fn participated(&self, uid: UserID) -> bool { self.registered(uid) } +} + +#[derive(Clone)] +struct MockEvent { + id: usize, + users: HashMap, +} + +impl MockEvent { + fn new(id: usize, registrants: HashSet, participants: HashSet) -> Self { + let users = registrants.into_iter() + .map(|uid| (uid, participants.contains(&uid))) + .collect(); + Self { id, users } + } +} + +impl std::fmt::Display for MockEvent { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "MockEvent{}({:?})", self.id, self.users) + } +} + +impl Event for &MockEvent { + fn registered(&self, uid: UserID) -> bool { + self.users.get(&uid).is_some() + } + + fn participated(&self, uid: UserID) -> bool { + self.users.get(&uid).is_some_and(|participated|*participated) + } +} + +impl Participants { + pub fn add(mut self, uid: UserID) -> Self { + self.0.push((uid, 1)); + self + } + + pub fn select(mut self, history: H, rng: &mut impl Rng, count: usize) + -> HashSet + where + H: Iterator, + ::Item: Event, + { + for event in history { + let mut modified = false; + for item in self.0.iter_mut() { + if event.registered(item.0) && !event.participated(item.0) { + modified = true; + item.1 += 1; + } + } + if !modified { + break; + } + } + + println!("{:?}", self.0); + + self.0.sample_weighted(rng, count, |item: &'_ (_, usize)| item.1 as f64) + .unwrap() + .map(|item| item.0) + .collect() + } +} + +async fn connect<'a, I: spond::auth::Identifier + From<&'a str>>(id: &'a str) -> Result { + let pw = std::env::var("SPOND_PASSWORD").expect("a password is required in SPOND_PASSWORD"); + let id: I = id.into(); + let auth = spond::auth::Login::new(id, pw); + let client = spond::Api::new(auth).await?; + Ok(client) +} + +async fn main() -> anyhow::Result<()> { + let filter = EnvFilter::try_from_default_env() + .unwrap_or_else(|_| EnvFilter::new("info")); + tracing_subscriber::registry() + .with(fmt::layer().pretty()) + .with(filter) + .init(); + + error!("Error Message"); + warn!("Warn Message"); + info!("Info Message"); + debug!("Debug Message"); + trace!("Trace Message"); + + let client = if let Ok(email) = std::env::var("SPOND_EMAIL") { + connect::(&email).await? + } else if let Ok(phone) = std::env::var("SPOND_PHONE") { + connect::(&phone).await? + } else { + panic!("no credentials provided"); + }; + + let _ = client; + + + let users = (0..25).map(UserID).collect::>(); + let mut events = Vec::new(); + + for id in 0..5 { + let mut rng = rand::rng(); + let want = users.iter().filter(|_| (&mut rng).random_bool(0.75)).map(|id|id.clone()).collect::>(); + + let mut participants = Participants::default(); + for uid in want.iter() { + participants = participants.add(*uid); + } + + let participants = participants.select(events.iter().rev(), &mut rng, 12); + let event = MockEvent::new(id, want, participants); + println!("{event}"); + events.push(event); + } + + for uid in users.into_iter() { + let (registered, participated) = events.iter() + .fold((0, 0), |(registered, participated), event| { + let registered = registered + if event.registered(uid) { 1 } else { 0 }; + let participated = participated + if event.participated(uid) { 1 } else { 0 }; + (registered, participated) + }); + + println!("{uid}: ({participated}/{registered}) {:.2}%", + (participated as f64) / (registered as f64) * 100f64); + } + + Ok(()) +} +} + +fn tracing_setup(filter: &str) { + let filter = EnvFilter::try_from_default_env() + .unwrap_or_else(|_| EnvFilter::new(filter)); + + tracing_subscriber::registry() + .with(fmt::layer().pretty()) + .with(filter) + .init(); +} + +async fn connect(authenticator: A, credentials: C) -> Result::Error, >::Error>> { + let auth = spond::authentication::Login; + + authenticator.authenticate(&auth, &credentials).await +} + +#[derive(serde::Deserialize)] +struct Spond() + +#[derive(serde::Deserialize)] +struct Sponds(Vec); + +impl spond::traits::endpoint::Private for Sponds { + const METHOD: spond::Method = spond::Method::GET; + type Schema = Self; + + fn path(&self, _: &SpodsW +} + +#[derive(serde::Seralize)] +struct SpondsQuery; + +#[tokio::main] +async fn main() { + tracing_setup("info"); + + #[cfg(feature="disabled")] + disabled::main().await; + + error!("Error Message"); + warn!("Warn Message"); + info!("Info Message"); + debug!("Debug Message"); + trace!("Trace Message"); + + let pw = std::env::var("SPOND_PASSWORD").expect("a password is required in SPOND_PASSWORD"); + let client = spond::reqwest::Public::new().expect("public client"); + let client = if let Ok(email) = std::env::var("SPOND_EMAIL") { + connect(client, spond::authentication::login::Email::new(&email, &pw)).await + } else if let Ok(phone) = std::env::var("SPOND_PHONE") { + connect(client, spond::authentication::login::Phone::new(&phone, &pw)).await + } else { + panic!("no credentials provided"); + }; + + let _ = client.execute(; +} diff --git a/turnerbund/Cargo.toml b/turnerbund/Cargo.toml new file mode 100644 index 0000000..678a760 --- /dev/null +++ b/turnerbund/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "turnerbund" +version = "0.1.0" +edition = "2024" + +[features] +disabled=[] + +[dependencies] +spond = { path = "../api", features = [ "reqwest" ] } +anyhow = "1.0.101" +async-trait = "0.1.89" +bon = "3.9.0" +chrono = { version = "0.4.43", features = ["serde"] } +http = "1.4.0" +rand = "0.10.0" +#reqwest = { version = "0.13.2", features = ["json", "zstd", "brotli", "gzip", "deflate"] } +reqwest-middleware = { version = "0.5.1", features = ["json", "http2"] } +serde = { version = "1.0.228", features = ["derive"] } +serde_json = "1.0.149" +thiserror = "2.0.18" +tokio = { version = "1.49.0", features = ["macros", "rt-multi-thread", "tracing"] } +tracing = { version = "0.1.44", features = ["log"] } +tracing-subscriber = { version = "0.3.22", features = ["serde", "json", "tracing", "env-filter", "chrono"] } +url = "2.5.8" diff --git a/turnerbund/src/api/api.rs b/turnerbund/src/api/api.rs new file mode 100644 index 0000000..dee5917 --- /dev/null +++ b/turnerbund/src/api/api.rs @@ -0,0 +1,201 @@ +use super::{ + Request, + error, + token, + auth, +}; +use crate::utils::Bool; + +#[async_trait::async_trait] +trait Interface { + fn client(&self) -> &reqwest::Client; + fn url(&self, endpoint: &str) -> Result; + fn current_token(&self) -> Option>; + async fn refresh_token(&self, api: Api) -> Result>, error::Token>; +} + +#[derive(Debug)] +struct Internal { + client: reqwest::Client, + base: reqwest::Url, + token_provider: T, +} + +impl Internal { + fn new(client: reqwest::Client, base: reqwest::Url, token_provider: T) + -> std::sync::Arc { + std::sync::Arc::new(Self { client, base, token_provider }) + } + + #[tracing::instrument(skip_all, fields(endpoint=request.endpoint(), request, token))] + async fn call(&self, request: &R, token: Option<&token::Token>) -> Result + { + let url = self.base.join(request.endpoint()).map_err(error::Api::Url)?; + let builder = self.client.request(R::METHOD, url); + let builder = if let Some(token) = token { + token.r#use(builder) + } else { + builder + }; + + let response = builder.json(request) + .send() + .await + .map_err(error::Api::Reqwest)?; + + match response.status() { + reqwest::StatusCode::OK => (), + status => return Err(error::Api::Http(status)), + } + let result: R::Response = response.json().await?; + Ok(result) + } +} + +async fn deserialize(response: reqwest::Response) -> Result +{ + let response: R::Response = response.json().await.map_err(error::Api::Reqwest)?; + Ok(response) +} + +#[tracing::instrument(skip_all, fields(url, request, token))] +async fn call(client: &reqwest::Client, url: reqwest::Url, request: &R, token: Option<&token::Token>) -> Result { + let builder = client.request(R::METHOD, url); + let builder = if let Some(token) = token { + builder.bearer_auth(token.as_ref()) + } else { + builder + }; + let response = builder.json(request) + .send() + .await + .map_err(error::Api::Reqwest)?; + + match response.status() { + reqwest::StatusCode::OK => + deserialize::(response).await, + status => Err(error::Api::Http(status)), + } +} + +#[async_trait::async_trait] +impl Interface for Internal { + fn client(&self) -> &reqwest::Client { + &self.client + } + + fn url(&self, endpoint: &str) -> Result { + self.base.join(endpoint) + } + + fn current_token(&self) -> Option> { + self.token_provider.current() + } + + async fn refresh_token(&self, api: Api) -> Result>, error::Token> { + self.token_provider.refresh(api).await + } +} + +#[derive(Debug)] +struct NoToken; + +#[async_trait::async_trait] +impl token::Provider for NoToken { + fn current(&self) -> Option> { + None + } + + async fn refresh(&self, _api: Api) -> Result>, error::Token> { + Ok(None) + } +} + +#[derive(Clone)] +pub struct Api(std::sync::Arc); + +impl Api { + pub async fn new(auth: A) -> Result + { + Self::new_with_base("https://api.spond.com", auth).await + } + + pub async fn new_with_base(base: &str, auth: A) -> Result { + let base = reqwest::Url::parse(base)?; + let host = base.host_str().unwrap().to_owned(); + + let client = reqwest::Client::builder() + //.https_only(true) + .redirect(reqwest::redirect::Policy::limited(1)) + .retry(reqwest::retry::for_host(host) + .max_retries_per_request(2) + .classify_fn(|req_rep| { + use reqwest::StatusCode; + match req_rep.status() { + Some(StatusCode::UNAUTHORIZED) => req_rep.retryable(), + _ => req_rep.success(), + } + })) + // TODO + //.cookie_store(true) + .user_agent("spond-selection-bot") + .read_timeout(std::time::Duration::from_secs(5)) + .connect_timeout(std::time::Duration::from_secs(15)) + .connection_verbose(true) + .build()?; + + let api = Api(Internal::new(client.clone(), base.clone(), NoToken)); + let provider = auth.authenticate(api).await?; + + tracing::info!("{:?}", provider); + let api = Api(Internal::new(client, base, provider)); + Ok(api) + } + + + pub async fn call(&self, request: &R) -> Result + { + //async fn call(&self, api: &Api, call: &C, request: &C::Request) -> Result> { + // let mut token = self.token_provider.current(); + // loop { + // match self.common.call(call, request, &token) { + // Err(error::Call::::Http(reqwest::StatusCode::UNAUTHORIZED)) if token.is_some_and(|token|token.expired()) + // => token = self.token_provider.refresh(api).map_err(error::Call::::Token)?, + // result => return result, + // } + // } + //} + + let client = self.0.client(); + + if R::Authorization::VALUE == false { + let url = self.0.url(request.endpoint())?; + call(client, url, request, None).await + } else { + let mut current = self.0.current_token(); + loop { + use std::ops::Deref; + let token = if let Some(ref token) = current { + Some(token.deref()) + } else { + None + }; + let url = self.0.url(request.endpoint())?; + current = match call(client, url, request, token).await { + Err(error::Api::Http(reqwest::StatusCode::UNAUTHORIZED)) if current.is_some_and(|t|t.expired()) + => self.0.refresh_token(self.clone()).await?, + result => break result, + } + } + } + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[tokio::test] + async fn mock() {} +} + diff --git a/turnerbund/src/api/auth.rs b/turnerbund/src/api/auth.rs new file mode 100644 index 0000000..ddb54de --- /dev/null +++ b/turnerbund/src/api/auth.rs @@ -0,0 +1,185 @@ +use async_trait::async_trait; +use thiserror::Error; +use crate::utils::False; + +use super::{ + Request, + error, +}; + +use serde::{ + Deserialize, + Serialize, + Serializer, + ser::SerializeStruct, +}; + +#[derive(Debug, Error)] +pub enum Error { + //#[error(transparent)] + //Provider(P) + #[error("invalid credentials")] + Credentials, +} + +#[async_trait] +pub trait Provider { + type TokenProvider: super::token::Provider + 'static; + + async fn authenticate(&self, api: super::Api) -> Result; +} + +pub trait Identifier: Sync + Send + Serialize + std::fmt::Debug { + const KEY: &'static str; +} + +macro_rules! transparent_identifier { + ($name:ident, $key:expr) => { + transparent_string!($name); + + impl Identifier for $name { + const KEY: &'static str = $key; + } + }; +} + +macro_rules! transparent_string { + ($name:ident) => { + #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)] + #[serde(transparent)] + pub struct $name(String); + + impl From<&str> for $name { + fn from(s: &str) -> Self { + s.to_string().into() + } + } + + impl From for $name { + fn from(s: String) -> Self { + Self(s) + } + } + + impl<'a> From<&'a $name> for &'a str { + fn from(id: &'a $name) -> Self { + &id.0 + } + } + + impl From<$name> for String { + fn from(id: $name) -> Self { + id.0 + } + } + }; +} + +transparent_string!(Password); +transparent_identifier!(Email, "email"); +transparent_identifier!(Phone, "phone"); + +#[derive(Debug)] +pub struct Login { + identifier: I, + password: Password, +} + +impl Login { + pub fn new>(identifier: I, password: P) -> Self { + Self { + identifier: identifier, + password: password.into(), + } + } +} + +impl Serialize for Login { + fn serialize(&self, serializer: S) -> Result { + let mut state = serializer.serialize_struct("Login", 2)?; + state.serialize_field(I::KEY, &self.identifier)?; + state.serialize_field("password", &self.password)?; + state.end() + } +} + +#[async_trait] +impl Provider for Login { + type TokenProvider = TokenProvider; + + async fn authenticate(&self, api: super::Api) -> Result { + Ok(api.call(self).await?.into()) + //todo!("implement me") + } +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Tokens { + access_token: super::token::Token, + refresh_token: super::token::Token, +} + +#[derive(Debug)] +pub struct TokenProvider { + access: std::sync::RwLock>, + refresh: std::sync::Mutex, +} + +impl From for TokenProvider { + fn from(tokens: Tokens) -> Self { + use std::sync::{Mutex,RwLock, Arc}; + Self { + access: RwLock::new(Arc::new(tokens.access_token)), + refresh: Mutex::new(tokens.refresh_token), + } + } +} + +#[async_trait::async_trait] +impl super::token::Provider for TokenProvider { + fn current(&self) -> Option> { + Some(self.access.read().ok()?.clone()) + } + + async fn refresh(&self, api: super::Api) -> Result>, super::error::Token> { + // TODO + let _ = api; + Err(super::error::Token::Expired(chrono::TimeDelta::seconds(-5))) + } +} + +impl Request for Login { + const METHOD: super::reqwest::Method = super::reqwest::Method::POST; + type Response = Tokens; + type Authorization = False; + + fn endpoint(&self) -> &str { + "core/v1/auth2/login" + } +} + + +#[cfg(test)] +mod test { + mod serialize { + use super::super::*; + use serde_json; + + #[test] + fn email_login() { + let login = Login::::new("user@spond.com", "secret"); + + let json = serde_json::to_string(&login).unwrap(); + assert_eq!(json, r#"{"email":"user@spond.com","password":"secret"}"#) + } + + #[test] + fn phone_login() { + let login = Login::::new("+1234567890", "secret"); + + let json = serde_json::to_string(&login).unwrap(); + assert_eq!(json, r#"{"phone":"+1234567890","password":"secret"}"#) + } + } +} diff --git a/turnerbund/src/api/endpoint/mod.rs b/turnerbund/src/api/endpoint/mod.rs new file mode 100644 index 0000000..a3dd347 --- /dev/null +++ b/turnerbund/src/api/endpoint/mod.rs @@ -0,0 +1,24 @@ +use serde::{Serialize, Deserialize}; + +pub trait Method { + const HTTP: http::Method; +} + +macro_rules! method { + ($name:ident) => { + struct $name; + + impl Method for $name { + const HTTP = http::Method::$name; + } + }; +} + +method!(GET); +method!(POST); + +pub trait Endpoint: Serialize { + type Result: Deserialize; + + fn path(&self) -> &str; +} diff --git a/turnerbund/src/api/error.rs b/turnerbund/src/api/error.rs new file mode 100644 index 0000000..5120e1b --- /dev/null +++ b/turnerbund/src/api/error.rs @@ -0,0 +1,29 @@ +pub trait Error: std::error::Error + std::fmt::Debug + Send + Sync + 'static {} +impl Error for E {} + +#[derive(Debug, thiserror::Error)] +pub enum Api { + #[error("reqwest")] + Reqwest(#[from] reqwest::Error), + + #[error("encode")] + Encode(serde_json::Error), + + #[error("decode")] + Decode(serde_json::Error), + + #[error("url")] + Url(#[from] url::ParseError), + + #[error("token")] + Token(#[from] Token), + + #[error("http")] + Http(reqwest::StatusCode), +} + +#[derive(Debug, thiserror::Error)] +pub enum Token { + #[error("expired token")] + Expired(chrono::TimeDelta), +} diff --git a/turnerbund/src/api/mod.rs b/turnerbund/src/api/mod.rs new file mode 100644 index 0000000..ce4563a --- /dev/null +++ b/turnerbund/src/api/mod.rs @@ -0,0 +1,32 @@ +pub mod auth; +pub mod token; +pub mod error; +pub mod request; +mod api; +pub use api::Api; +pub use request::{ + Request, +}; + +use reqwest_middleware::reqwest; + +#[derive(Debug, thiserror::Error)] +pub enum Error { + #[error("unspecified")] + Unspecified, + + #[error("reqwest error")] + Reqwest(#[from] reqwest::Error), + + #[error("middleware error")] + Middleware(anyhow::Error), + + #[error("url parser error")] + UrlParseError(#[from] url::ParseError), + + #[error("http status code")] + Http(reqwest::StatusCode), + + #[error(transparent)] + Custom(Auth) +} diff --git a/turnerbund/src/api/request.rs b/turnerbund/src/api/request.rs new file mode 100644 index 0000000..b9d880e --- /dev/null +++ b/turnerbund/src/api/request.rs @@ -0,0 +1,13 @@ +use crate::utils::Bool; + +trait Authorization: Bool {} + +impl Authorization for T {} + +pub trait Request: Sized + std::fmt::Debug + serde::Serialize { + const METHOD: reqwest::Method = reqwest::Method::GET; + type Authorization: Authorization; + type Response: for<'a> serde::Deserialize<'a> + Sized; + + fn endpoint(&self) -> &str; +} diff --git a/turnerbund/src/api/token.rs b/turnerbund/src/api/token.rs new file mode 100644 index 0000000..73965fb --- /dev/null +++ b/turnerbund/src/api/token.rs @@ -0,0 +1,38 @@ +use async_trait::async_trait; + +#[derive(Debug, Clone, serde::Deserialize)] +pub struct Token { + token: String, + expiration: chrono::DateTime, +} + +impl AsRef for Token { + fn as_ref(&self) -> &str { + &self.token + } +} + +impl Token { + pub fn expired(&self) -> bool { + self.expiration < chrono::Utc::now() + } + + pub fn expired_in(&self, offset: chrono::TimeDelta) -> bool { + self.time_delta() < offset + } + + pub fn time_delta(&self) -> chrono::TimeDelta { + self.expiration - chrono::Utc::now() + } + + pub fn r#use(&self, builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder { + builder.bearer_auth(&self.token) + } +} + +#[async_trait] +pub trait Provider: std::fmt::Debug + Send + Sync { + fn current(&self) -> Option>; + + async fn refresh(&self, api: super::Api) -> Result>, super::error::Token>; +} diff --git a/turnerbund/src/client/mod.rs b/turnerbund/src/client/mod.rs new file mode 100644 index 0000000..83f0aad --- /dev/null +++ b/turnerbund/src/client/mod.rs @@ -0,0 +1,10 @@ +use reqwest_middleware::reqwest; +use reqwest_middleware::ClientWithMiddleware as Backend; + +struct Client { + backend: Backend, +} + +impl Client { + +} diff --git a/turnerbund/src/id.rs b/turnerbund/src/id.rs new file mode 100644 index 0000000..e628b3e --- /dev/null +++ b/turnerbund/src/id.rs @@ -0,0 +1,74 @@ +use serde::{Serialize, Deserialize, Serializer, Deserializer}; +use serde::de; +use std::fmt; +use std::str::FromStr; +use super::api::Api; + +#[derive(Debug)] +pub enum ParseError { + Length(usize), + IntError(std::num::ParseIntError), +} + +impl From for ParseError { + fn from(e: std::num::ParseIntError) -> Self { + Self::IntError(e) + } +} + +impl fmt::Display for ParseError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Length(len) => write!(f, "Id strig must be 32 characters, got {}", len), + Self::IntError(e) => write!(f, "{}", e), + } + } +} + +pub trait Marker { + async fn resolve(id: Id, api: Api) -> Result; +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct Id(u128, std::marker::PhantomData); + +impl Id { + pub fn new(value: u128) -> Self { + Self(value, std::marker::PhantomData) + } + + pub fn value(&self) -> u128 { + self.0 + } +} + +impl fmt::Display for Id { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:032X}", self.0) + } +} + +impl FromStr for Id { + type Err = ParseError; + + fn from_str(s: &str) -> Result { + match s.len() { + 32 => Ok(Self::new(u128::from_str_radix(s, 16)?)), + len => Err(ParseError::Length(len)), + } + } +} + +impl Serialize for Id { + fn serialize(&self, serializer: S) -> Result { + serializer.serialize_str(&self.to_string()) + } +} + +impl<'de, T: Marker> Deserialize<'de> for Id { + fn deserialize>(deserializer: D) -> Result { + String::deserialize(deserializer)? + .parse() + .map_err(de::Error::custom) + } +} diff --git a/turnerbund/src/main.rs b/turnerbund/src/main.rs new file mode 100644 index 0000000..fe9b31d --- /dev/null +++ b/turnerbund/src/main.rs @@ -0,0 +1,51 @@ +use tracing_subscriber::prelude::*; +use tracing_subscriber::{fmt, EnvFilter}; +pub use tracing::{error, warn, info, debug, trace}; + +fn tracing_setup(filter: &str) { + let filter = EnvFilter::try_from_default_env() + .unwrap_or_else(|_| EnvFilter::new(filter)); + + tracing_subscriber::registry() + .with(fmt::layer().pretty()) + .with(filter) + .init(); +} + +async fn connect(authenticator: A, credentials: C) -> Result::Error, >::Error>> { + let auth = spond::authentication::Login; + + authenticator.authenticate(&auth, &credentials).await +} + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + tracing_setup("info"); + + #[cfg(feature="disabled")] + disabled::main().await; + + error!("Error Message"); + warn!("Warn Message"); + info!("Info Message"); + debug!("Debug Message"); + trace!("Trace Message"); + + let pw = std::env::var("SPOND_PASSWORD").expect("a password is required in SPOND_PASSWORD"); + let client = spond::reqwest::Public::new().expect("public client"); + let client = if let Ok(email) = std::env::var("SPOND_EMAIL") { + connect(client, spond::authentication::login::Email::new(&email, &pw)).await + } else if let Ok(phone) = std::env::var("SPOND_PHONE") { + connect(client, spond::authentication::login::Phone::new(&phone, &pw)).await + } else { + panic!("no credentials provided"); + }?; + + + use spond::traits::client::Private; + + let _ = client.execute(&spond::schema::sponds::Sponds::default(), &spond::schema::sponds::Upcoming).await?; + + + Ok(()) +} diff --git a/turnerbund/src/select.rs b/turnerbund/src/select.rs new file mode 100644 index 0000000..ef0abcc --- /dev/null +++ b/turnerbund/src/select.rs @@ -0,0 +1,166 @@ +use rand::prelude::*; +use std::collections::HashSet; +use std::collections::HashMap; + +#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)] +struct UserID(u128); + +impl std::fmt::Display for UserID { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "UserID({})", self.0) + } +} + +#[derive(Default)] +struct Participants(Vec<(UserID, usize)>); + +trait Event { + fn registered(&self, uid: UserID) -> bool; + fn participated(&self, uid: UserID) -> bool { self.registered(uid) } +} + +impl Participants { + pub fn add(mut self, uid: UserID) -> Self { + self.0.push((uid, 1)); + self + } + + pub fn select(mut self, history: IntoIterator, rng: &mut impl Rng, count: usize) + -> HashSet + { + for event in history { + let mut modified = false; + for item in self.0.iter_mut() { + if event.registered(item.0) && !event.participated(item.0) { + modified = true; + item.1 += 1; + } + } + if !modified { + break; + } + } + + println!("{:?}", self.0); + + self.0.sample_weighted(rng, count, |item: &'_ (_, usize)| item.1 as f64) + .unwrap() + .map(|item| item.0) + .collect() + } +} + +#[cfg(feature="disabled")] +mod disabled { + +//mod select; +//use select::WeightedSet; + +use tracing_subscriber::prelude::*; +use tracing_subscriber::{fmt, EnvFilter}; +pub use tracing::{error, warn, info, debug, trace}; + + +#[derive(Debug, thiserror::Error)] +pub enum NoError {} + + + +#[derive(Clone)] +struct MockEvent { + id: usize, + users: HashMap, +} + +impl MockEvent { + fn new(id: usize, registrants: HashSet, participants: HashSet) -> Self { + let users = registrants.into_iter() + .map(|uid| (uid, participants.contains(&uid))) + .collect(); + Self { id, users } + } +} + +impl std::fmt::Display for MockEvent { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "MockEvent{}({:?})", self.id, self.users) + } +} + +impl Event for &MockEvent { + fn registered(&self, uid: UserID) -> bool { + self.users.get(&uid).is_some() + } + + fn participated(&self, uid: UserID) -> bool { + self.users.get(&uid).is_some_and(|participated|*participated) + } +} + +async fn connect<'a, I: spond::auth::Identifier + From<&'a str>>(id: &'a str) -> Result { + let pw = std::env::var("SPOND_PASSWORD").expect("a password is required in SPOND_PASSWORD"); + let id: I = id.into(); + let auth = spond::auth::Login::new(id, pw); + let client = spond::Api::new(auth).await?; + Ok(client) +} + +async fn main() -> anyhow::Result<()> { + let filter = EnvFilter::try_from_default_env() + .unwrap_or_else(|_| EnvFilter::new("info")); + tracing_subscriber::registry() + .with(fmt::layer().pretty()) + .with(filter) + .init(); + + error!("Error Message"); + warn!("Warn Message"); + info!("Info Message"); + debug!("Debug Message"); + trace!("Trace Message"); + + let client = if let Ok(email) = std::env::var("SPOND_EMAIL") { + connect::(&email).await? + } else if let Ok(phone) = std::env::var("SPOND_PHONE") { + connect::(&phone).await? + } else { + panic!("no credentials provided"); + }; + + let _ = client; + + + let users = (0..25).map(UserID).collect::>(); + let mut events = Vec::new(); + + for id in 0..5 { + let mut rng = rand::rng(); + let want = users.iter().filter(|_| (&mut rng).random_bool(0.75)).map(|id|id.clone()).collect::>(); + + let mut participants = Participants::default(); + for uid in want.iter() { + participants = participants.add(*uid); + } + + let participants = participants.select(events.iter().rev(), &mut rng, 12); + let event = MockEvent::new(id, want, participants); + println!("{event}"); + events.push(event); + } + + for uid in users.into_iter() { + let (registered, participated) = events.iter() + .fold((0, 0), |(registered, participated), event| { + let registered = registered + if event.registered(uid) { 1 } else { 0 }; + let participated = participated + if event.participated(uid) { 1 } else { 0 }; + (registered, participated) + }); + + println!("{uid}: ({participated}/{registered}) {:.2}%", + (participated as f64) / (registered as f64) * 100f64); + } + + Ok(()) +} +} + diff --git a/turnerbund/src/select/candidate.rs b/turnerbund/src/select/candidate.rs new file mode 100644 index 0000000..ac1a094 --- /dev/null +++ b/turnerbund/src/select/candidate.rs @@ -0,0 +1,48 @@ +use super::Key; +use std::cmp::Ordering; + +#[derive(Debug)] +pub struct Candidate { + item: T, + key: Key, +} + +impl Candidate { + pub fn new_with_key(item: T, key: Key) -> Self { + Self { item, key } + } + + pub fn new(item: T, rng: R, weight: W) -> Option + where + R: FnOnce() -> F, + F: Into, + W: Into, + { + Key::new(rng, weight).map(|key|Self::new_with_key(item, key)) + } + + pub fn item(self) -> T { + self.item + } +} + +impl Ord for Candidate { + fn cmp(&self, other: &Self) -> Ordering { + // Reverse for max-heap: largest key is "greatest" + other.key.partial_cmp(&self.key).unwrap().reverse() + } +} + +impl PartialOrd for Candidate { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl PartialEq for Candidate { + fn eq(&self, other: &Self) -> bool { + self.key == other.key + } +} + +impl Eq for Candidate {} diff --git a/turnerbund/src/select/key.rs b/turnerbund/src/select/key.rs new file mode 100644 index 0000000..e75b5fa --- /dev/null +++ b/turnerbund/src/select/key.rs @@ -0,0 +1,31 @@ +// Key newtype wrapping a f64 in the range [0.0,1.0] +#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)] +pub struct Key(f64); + +impl Key { + pub fn new(rng: R, weight: W) -> Option + where + R: FnOnce() -> F, + F: Into, + W: Into, + { + let weight = weight.into(); + + if weight.is_finite() && weight > 0.0 { + let u = -rng().into().ln(); + Some(Key((u / weight).recip())) + } else { + None + } + } +} + +impl Ord for Key { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + // we are always in range [0.0,1.0] + self.0.partial_cmp(&other.0).unwrap() + } +} + +impl Eq for Key {} + diff --git a/turnerbund/src/user.rs b/turnerbund/src/user.rs new file mode 100644 index 0000000..f75071f --- /dev/null +++ b/turnerbund/src/user.rs @@ -0,0 +1,2 @@ +struct Profile; +struct User; diff --git a/turnerbund/src/utils.rs b/turnerbund/src/utils.rs new file mode 100644 index 0000000..698dc9e --- /dev/null +++ b/turnerbund/src/utils.rs @@ -0,0 +1,19 @@ +trait BoolValue {} + +pub trait Bool: BoolValue { + const VALUE: bool; +} + +pub struct True; +pub struct False; + +impl BoolValue for True {} +impl BoolValue for False {} + +impl Bool for True { + const VALUE: bool = true; +} + +impl Bool for False { + const VALUE: bool = false; +}