nonapode/spond
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

working example

Browse source
This commit is contained in:
Jonas Rabenstein 2026-03-05 01:57:37 +01:00
commit e69bcfc23d
18 changed files with 1290 additions and 252 deletions
Download patch file Download diff file Expand all files Collapse all files

9
cli/Cargo.toml
View file

@ -9,11 +9,18 @@ bon = "3.9.0"
chrono = { version = "0.4.44", features = ["serde"] }
clap = { version = "4.5.60", features = ["cargo", "derive", "env" ] }
env_logger = "0.11.9"
futures = "0.3.32"
http = "1.4.0"
log = "0.4.29"
rand = "0.10.0"
restson = "1.5.0"
rpassword = "7.4.0"
serde = { version = "1.0.228", features = ["derive"] }
serde_json = "1.0.149"
spond-macros = { version = "0.1.0", path = "../macros" }
serde_qs = "1.0.0"
spond-api = { version = "0.1.0", path = "../api" }
thiserror = "2.0.18"
#spond-macros = { version = "0.1.0", path = "../macros" }
tokio = { version = "1.49.0", features = ["macros", "rt-multi-thread"] }
url = "2.5.8"
xdg = "3.0.0"

103
cli/src/api/mod.rs
View file

@ -1,103 +0,0 @@
//use bon::Builder;
use chrono::{DateTime,Utc};
use serde::{Serialize, Deserialize};
//use restson::{RestClient, RestPath, Error};
//
#[derive(Serialize)]
pub enum Order {
Ascending,
Descending,
}
impl AsRef<str> for Order {
fn as_ref(&self) -> &str {
match self {
Self::Ascending => "asc",
Self::Descending => "desc",
}
}
}
impl From<bool> for Order {
fn from(ascending: bool) -> Self {
if ascending {
Self::Ascending
} else {
Self::Descending
}
}
}
#[derive(Debug, Deserialize)]
pub struct Spond {
id: String,
}
//
//#[bon::builder]
//#[builder(on(bool, default=false))]
//fn sponds(
// comments: bool,
// hidden: bool,
// add_profile_info: bool,
// scheduled=bool,
// #[builder(into)]
// order=Order,
// #[builder(default = 20)]
// max=usize,
// min_end_timestamp=Option<DateTime<Utc>>,
// max_end_timestamp=Option<DateTime<Utc>>,
//) -> Get<(), Vec<Spond>> {
//crate::get!(sponds(
// comments: bool,
// hidden: bool,
// add_profile_info: bool,
// scheduled,
// #[builder(into, default=Order::Ascending)] order: Order,
// #[builder(default=20)]max: usize,
// min_end_timestamp: Option<DateTime<Utc>>,
// max_end_timestamp: Option<DateTime<Utc>>,
// ),
// () => "sponds" -> Vec<Spond>);
#[spond_macros::endpoint((id:u128):"/spond/{id:032X}/info", (eid:u128, uid:u128): "/spond/{eid:032X}/response/{uid:032X}")]
pub async fn sponds(result: serde_json::Value,
#[query] comments: Option<bool>,
#[query] hidden: Option<bool>,
#[body] min_end_timestamp: Option<DateTime<Utc>>,
) -> serde_json::Value {
result
}
/*
crate::post!(post(
comments: bool,
hidden: bool,
add_profile_info: bool,
scheduled: bool,
#[builder(into)] order: Order,
#[builder(default=20)]max: usize,
)
min_end_timestamp: Option<DateTime<Utc>>,
max_end_timestamp: Option<DateTime<Utc>>,
() => "sponds" -> Vec<Spond>);
*/
//impl Search {
// with_comments(
//#[bon::builder]
//#[builder(on(bool, default=false))]
//fn sponds(
// comments: bool,
// hidden: bool,
// add_profile_info: bool,
// scheduled=bool,
// #[builder(into)]
// order=Order,
// #[builder(default = 20)]
// max=usize,
// min_end_timestamp=Option<DateTime<Utc>>,
// max_end_timestamp=Option<DateTime<Utc>>,
//) -> Search {
//}

198
cli/src/authentication.rs
View file

@ -1,11 +1,7 @@
use clap::{Args, ArgGroup};
use restson::{RestClient, RestPath, Response};
use restson::RestClient;
use anyhow::{Result, Error};
use serde::{
ser::{Serialize, Serializer, SerializeMap},
Deserialize,
};
use chrono::{DateTime, Utc};
use std::str::{FromStr};
#[derive(Args, Debug)]
#[command(group(
@ -14,10 +10,10 @@ use chrono::{DateTime, Utc};
))]
pub struct Authentication {
#[arg(long)]
access: Option<Token>,
access: Option<Access>,
#[arg(long)]
refresh: Option<Token>,
refresh: Option<Refresh>,
#[arg(long)]
email: Option<Email>,
@ -26,13 +22,18 @@ pub struct Authentication {
phone: Option<Phone>,
}
fn bearer(mut client: RestClient, token: &str) -> Result<RestClient> {
client.set_header("Authorization", &format!("Bearer {}", token))?;
Ok(client)
}
impl Authentication {
pub async fn apply(self, client: RestClient) -> Result<RestClient> {
let client = match (self.access, self.refresh, self.email, self.phone) {
(Some(v), None, None, None) => v.apply(client)?,
(None, Some(v), None, None) => Tokens::authenticate(client, v).await?,
(None, None, Some(v), None) => Tokens::authenticate(client, v).await?,
(None, None, None, Some(v)) => Tokens::authenticate(client, v).await?,
pub async fn apply(&self, client: RestClient) -> Result<RestClient> {
let client = match (self.access.as_ref(), self.refresh.as_ref(), self.email.as_ref(), self.phone.as_ref()) {
(Some(ref v), None, None, None) => v.apply(client)?,
(None, Some(ref v), None, None) => v.apply(client).await?,
(None, None, Some(ref v), None) => v.apply(client).await?,
(None, None, None, Some(ref v)) => v.apply(client).await?,
(None, None, None, None) => client,
(a, b, c, d) => anyhow::bail!("invalid authentication: {} + {} + {} + {}", a.is_some(), b.is_some(), c.is_some(), d.is_some()),
};
@ -40,126 +41,87 @@ impl Authentication {
}
}
mod identifier {
#[derive(Debug, Clone)]
pub struct Email;
#[derive(Debug, Clone)]
pub struct Phone;
}
trait Identifier: Clone {
const NAME: &'static str;
type Value: std::str::FromStr<Err=Self::Error> + std::fmt::Debug + Clone + serde::Serialize;
type Error: std::error::Error + Send + Sync + 'static;
}
impl Identifier for identifier::Email {
const NAME: &'static str = "email";
type Value = String;
type Error = <String as std::str::FromStr>::Err;
}
impl Identifier for identifier::Phone {
const NAME: &'static str = "phone";
type Value = String;
type Error = <String as std::str::FromStr>::Err;
}
#[derive(Debug, Clone)]
struct WithPassword<I: Identifier> {
value: I::Value,
struct WithPassword {
value: String,
password: String,
}
impl<I: Identifier> Serialize for WithPassword<I> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>
{
let mut map = serializer.serialize_map(Some(2))?;
map.serialize_entry(I::NAME, &self.value)?;
map.serialize_entry("password", &self.password)?;
map.end()
}
}
impl<I: Identifier> RestPath<()> for WithPassword<I> {
fn get_path(_: ()) -> std::result::Result<String, restson::Error> {
Ok(String::from("auth2/login"))
}
}
type Email = WithPassword<identifier::Email>;
type Phone = WithPassword<identifier::Phone>;
impl<I: Identifier> std::str::FromStr for WithPassword<I> {
type Err= Error;
impl FromStr for WithPassword {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let password = match std::env::var("SPOND_PASSWORD") {
Ok(password) => password,
Err(_) => rpassword::prompt_password("Password: ")?,
};
let value = I::Value::from_str(s)?;
let value = String::from_str(s)?;
Ok(Self { value, password })
}
}
#[derive(Debug, Deserialize)]
struct Tokens {
#[serde(rename = "accessToken")]
access: TokenWithExpiration,
#[serde(rename = "refreshToken")]
refresh: TokenWithExpiration,
}
impl Tokens {
async fn authenticate<R: serde::Serialize + RestPath<()>>(client: RestClient, request: R) -> Result<RestClient> {
let tokens: Response<Self> = client.post_capture((), &request).await?;
tokens.into_inner().apply(client)
}
fn apply(self, client: RestClient) -> Result<RestClient> {
println!("refresh: {self:?}");
self.access.token.apply(client)
}
}
#[derive(Debug, Deserialize)]
struct TokenWithExpiration {
token: Token,
#[allow(unused)]
expiration: DateTime<Utc>
}
#[derive(Debug, Clone, Deserialize)]
struct Token(String);
impl Serialize for Token {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>
{
let mut map = serializer.serialize_map(Some(1))?;
map.serialize_entry("token", &self.0)?;
map.end()
#[derive(Debug, Clone)]
struct Email(WithPassword);
impl Email {
async fn apply(&self, client: RestClient) -> Result<RestClient> {
let tokens = spond_api::authentication::email(&client, &self.0.value, &self.0.password).await?;
bearer(client, tokens.access.token.as_ref())
}
}
impl Token {
fn apply(self, mut client: RestClient) -> Result<RestClient> {
client.set_header("Authorization", &format!("Bearer {}", self.0))?;
Ok(client)
}
}
impl RestPath<()> for Token {
fn get_path(_: ()) -> std::result::Result<String, restson::Error> {
Ok(String::from("auth2/login/refresh"))
}
}
impl std::str::FromStr for Token {
type Err = std::convert::Infallible;
impl FromStr for Email {
type Err= <WithPassword as FromStr>::Err;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(Self(s.to_string()))
Ok(Self(WithPassword::from_str(s)?))
}
}
#[derive(Debug, Clone)]
struct Phone(WithPassword);
impl Phone {
async fn apply(&self, client: RestClient) -> Result<RestClient> {
let tokens = spond_api::authentication::phone(&client, &self.0.value, &self.0.password).await?;
bearer(client, tokens.access.token.as_ref())
}
}
impl FromStr for Phone {
type Err= <WithPassword as FromStr>::Err;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(Self(WithPassword::from_str(s)?))
}
}
#[derive(Debug, Clone)]
struct Access(String);
impl Access {
fn apply(&self, client: RestClient) -> Result<RestClient> {
bearer(client, &self.0)
}
}
impl FromStr for Access {
type Err = std::convert::Infallible; // parsing a String never fails
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(Access(s.to_string()))
}
}
#[derive(Debug, Clone)]
struct Refresh(String);
impl Refresh {
async fn apply(&self, client: RestClient) -> Result<RestClient> {
let tokens = spond_api::authentication::token(&client, &self.0).await?;
bearer(client, tokens.access.token.as_ref())
}
}
impl FromStr for Refresh {
type Err = std::convert::Infallible; // parsing a String never fails
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(Refresh(s.to_string()))
}
}

26
cli/src/history.rs Normal file
View file

@ -0,0 +1,26 @@
use std::fd::{File, OpenOptions};
use std::io::{BufReader, BufWriter, Read, Write};
use xdg::BaseDirectories;
pub struct History(File);
impl History {
pub fn open(serie: spond_api::SeriesId) -> std::io::Result<Self> {
let xdg_dirs = BaseDirectories::with_prefix(env!("CARGO_PKG_NAME"));
let path = xdg_dirs.place_state_file(format!("{}.bin", serie))?;
let file = OpenOptions::new()
.create(true)
.append(true)
.read(true)
.open(&path)?;
Ok(Self(file))
}
pub fn append<I>(&mut self, selected: usize, ids: I) -> io::Result<()>
where
I: IntoIterator,
I::Item: Into<u128>,
I::IntoIter: ExactSizeIterator,
}

398
cli/src/main.rs
View file

@ -2,11 +2,10 @@ use clap::Parser;
use restson::RestClient;
use anyhow::Result;
use url::Url;
use spond_api as api;
use xdg::BaseDirectories as xdg;
mod authentication;
mod api;
mod request;
#[derive(Parser, Debug)]
#[command(author, version, about)]
@ -14,27 +13,176 @@ struct Cli {
#[command(flatten)]
authentication: authentication::Authentication,
#[arg(long, default_value_t)]
seed: Seed,
#[arg(long)]
vip: Option<Vec<api::util::X128>>,
#[arg(long)]
series: Option<api::util::X128>,
#[arg(long)]
heading: Option<String>,
#[arg(long, default_value = "https://api.spond.com/")]
base: Url,
}
impl Cli {
pub async fn client(self) -> Result<RestClient> {
pub async fn client(&self) -> Result<RestClient> {
let base = self.base.join("/core/v1/")?;
let client = RestClient::new(base.as_str())?;
Ok(self.authentication.apply(client).await?)
}
}
#[derive(Debug, serde::Deserialize)]
struct Spond(serde_json::Value);
#[derive(Debug, Clone, Copy)]
struct Seed(u64);
#[derive(Debug, serde::Deserialize)]
struct Sponds(Vec<Spond>);
impl Default for Seed {
fn default() -> Self {
use rand::{rng, RngExt};
Self(rng().random())
}
}
impl restson::RestPath<()> for Sponds {
fn get_path(_: ()) -> std::result::Result<String, restson::Error> {
Ok(String::from("sponds"))
impl std::str::FromStr for Seed {
type Err = <u64 as std::str::FromStr>::Err;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
u64::from_str_radix(s, 16).map(Seed)
}
}
impl<T: Into<u64>> From<T> for Seed {
fn from(seed: T) -> Self {
Self(seed.into())
}
}
impl std::fmt::Display for Seed {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:016X}", self.0)
}
}
impl Seed {
pub fn shuffle<'a, T, F, W>(&self, input: &'a [T], weight: F) -> Result<Vec<T>>
where
F: Fn(T) -> W,
W: Into<f64>,
T: Copy
{
use rand::{SeedableRng, rngs::StdRng};
let len = input.len();
let sample = rand::seq::index::sample_weighted(
&mut StdRng::seed_from_u64(self.0),
len,
|idx| weight(input[idx]),
len,
)?;
log::debug!("sample: {:?}", sample);
Ok(sample.into_iter().map(move |idx| input[idx]).collect())
}
}
#[derive(Debug)]
struct Weights<Id>(std::collections::HashMap<Id, usize>);
use std::hash::Hash;
impl<Id> Default for Weights<Id>
where
Id: Eq + Hash + Copy,
{
fn default() -> Self {
Self(std::collections::HashMap::default())
}
}
impl<Id> Weights<Id>
where
Id: Eq + Hash + Copy,
{
fn path(serie: api::SeriesId) -> Result<std::path::PathBuf> {
let dirs = xdg::with_prefix(env!("CARGO_PKG_NAME"));
Ok(dirs.place_state_file(format!("{serie}.json"))?)
}
pub fn update(&mut self, keep: &[Id]) -> &mut Self {
// remove keys not in keep
self.0.retain(|key, _| keep.contains(key));
// adjust weights
for &key in keep {
let val = self.0.entry(key).or_insert(0);
*val = val.saturating_add(1);
}
self
}
pub fn weight(&self, index: impl Into<Id>) -> f64 {
let extra = self.0.get(&index.into()).copied().unwrap_or(0);
let sum = 1f64 + (extra as f64);
if sum.is_infinite() { f64::MAX } else { sum }
}
}
impl<Id> Weights<Id>
where
Id: Eq + Hash + Copy + serde::de::DeserializeOwned
{
pub fn load(serie: api::SeriesId) -> Result<Self> {
let path = Self::path(serie)?;
log::debug!("load {path:?}");
let file = std::fs::OpenOptions::new()
.read(true)
.open(path)?;
let data: std::collections::HashMap<Id, usize> = serde_json::from_reader(file)?;
Ok(Self(data))
}
}
impl<Id> Weights<Id>
where
Id: Eq + Hash + Copy + serde::Serialize
{
pub fn store(&self, serie: api::SeriesId) -> Result<()> {
use std::fs::{File, rename};
use std::io::{BufWriter, Write};
let path = Self::path(serie)?;
log::debug!("store {path:?}");
let tmp = path.with_extension("json.tmp");
// create temporary file
let file = File::create(&tmp)?;
let mut writer = BufWriter::new(file);
// write data to temporary file
serde_json::to_writer_pretty(&mut writer, &self.0)?;
// flush write buffer
writer.flush()?;
// sync to disc
writer.get_ref().sync_all()?;
// close file
drop(writer);
// atomic replace old file
rename(&tmp, &path)?;
Ok(())
}
}
@ -42,32 +190,212 @@ impl restson::RestPath<()> for Sponds {
async fn main() -> Result<()> {
env_logger::init();
let client = Cli::parse().client().await?;
// https://api.spond.com/core/v1/sponds?includeComments=true&includeHidden=false&addProfileInfo=true&scheduled=true&order=asc&max=20&prevId=F94829E35A9B4A48A042646C8B658B01&minStartTimestamp=2026-04-11T09:45:00Z&minEndTimestamp=2026-02-26T23:00:00.001Z
if false {
let query = [
("includeComments", "true"),
("includeHidden", "false"),
("addProfileInfo", "true"),
("scheduled", "true"),
("order", "asc"),
("max", "20"),
];
for spond in client.get_with::<_, Sponds>((), &query).await?.into_inner().0 {
println!("{spond:?}");
}
let cli = Cli::parse();
let seed = cli.seed;
let series = cli.series.map(api::SeriesId::new);
let heading = cli.heading.as_ref();
let vip: Vec<api::MemberId> = if let Some(ref vip) = cli.vip {
vip.into_iter().map(|id| api::MemberId::new(*id)).collect()
} else {
let request = api::sponds()
.comments(true)
.hidden(false)
.add_profile_info(false)
.scheduled(true)
;
for spond in request.call(&client).await? {
println!("{spond:?}");
[
0xEB07B45E45E6449386E70A7411816B6Fu128,
0xD05F8574AC544C8DB1A7DC5B6347AA49u128,
].map(|x| api::MemberId::new(x.into())).into()
};
let client = cli.client().await?;
let client = &client;
log::info!("seed: {seed}");
if let Some(series) = series {
log::info!("series: {series}");
}
if let Some(heading) = heading {
log::info!("heading: {heading}");
}
if true {
let now = chrono::Utc::now();
let sponds = api::spond::search()
.include_comments(true)
.order(api::Order::Ascending)
.max(1000)
.min_start_timestamp(now)
.max_end_timestamp(now + chrono::Duration::weeks(1))
.call(client).await?;
for spond in sponds.iter()
.filter(|spond| {
let result = series.is_none_or(|series| spond.series_id.is_some_and(|remote| remote == series))
&& heading.is_none_or(|heading| spond.heading == *heading);
log::trace!("{}: {:?} == {:?} => {:?}", spond.heading, spond.series_id, series, result);
result
})
{
log::debug!("{:?}", spond.responses);
let spond = &spond;
let decline = |id: &api::MemberId| {
log::info!("remove {0}", *id);
spond.decline(*id).call(client)
};
let accept = |id: &api::MemberId| {
log::info!("accept {0}", *id);
spond.accept(*id).call(client)
};
let mut weights = spond.series_id.and_then(|series| Weights::load(series).ok()).unwrap_or_else(Weights::default);
log::info!("{weights:?}");
let (vip, interested) = {
let mut r = (Vec::new(), Vec::new());
for id in spond.responses.accepted_ids.iter()
.chain(spond.responses.waitinglist_ids.iter()) {
(if vip.contains(id) { &mut r.0 } else { &mut r.1 }).push(*id);
}
(r.0, seed.shuffle(&r.1, |idx| weights.weight(idx))?)
};
// remove all registered participants
let results = futures::future::join_all(interested.iter().map(|id|decline(id))).await;
log::debug!("{results:?}");
// register them in order
let mut responses = None;
for id in interested.iter() {
responses = Some(accept(id).await?);
}
if let Some(responses) = responses {
log::debug!("{responses:?}");
let reorder = |mut responses: api::Responses| async move {
// someone might have been registered right now
let mut extra = Vec::new();
loop {
log::debug!("vip: {vip:?}");
log::debug!("interested: {interested:?}");
log::debug!("extra: {extra:?}");
let reorder = responses.accepted_ids.iter()
.chain(responses.waitinglist_ids.iter())
.filter(|id| !(vip.contains(*id) || interested.contains(*id) || extra.contains(*id)))
.cloned()
.collect::<Vec<_>>();
if reorder.is_empty() {
let update = interested.iter()
.filter(|id| responses.waitinglist_ids.contains(id))
.cloned()
.collect::<Vec<_>>();
break Ok::<Vec<api::MemberId>, anyhow::Error>(update);
}
let futures = futures::future::join_all(reorder.iter().map(|id|decline(id))).await;
log::debug!("{futures:?}");
for id in reorder.into_iter() {
responses = accept(&id).await?;
extra.push(id);
}
tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
}
};
let update = reorder(responses).await?;
weights.update(&update);
} else {
weights = Weights::default();
};
log::debug!("{weights:?}");
if let Some(series) = spond.series_id {
let _ = weights.store(series)?;
}
}
//for member in spond.responses.accepted_ids.iter()
// .chain(spond.responses.waitinglist_ids.iter()) {
// let result = map.insert(member, 1);
// println!("{:?}: {:?}", member, result);
//}
//println!("{:?}", map);
//println!("{:?}", &spond.responses);
//let response = spond.response(member)
// .accepted(false)
// .call(&client)
// .await?;
//println!("{:?}", &response);
} else if true {
let profile = api::profile::identity(&client).await;
if let Ok(profile) = profile {
println!("profile: {:?}: {profile}", &profile.id);
}
} else if false {
//let query = [
// ("includeSponds", "true"),
//];
//let series = client.get_with::<_, Series>((0xCCBE049C31DA4FB691158E3FBC2DFBC8u128,), &query).await?.into_inner().0;
let now = api::util::DateTime::default();
let sponds = api::spond::search()
.include_comments(true)
.order(api::Order::Ascending)
.max(100)
.series_id(api::SeriesId::new(0x9333BDD4135E48BEAE88F1C3006A5FC0u128.into()))
.min_end_timestamp(now)
.min_start_timestamp(now)
.call(&client).await?;
for spond in sponds.iter() {
println!("{spond:?}");
//let spond = api::spond().call(&client, api::SpondId::new(0xF131CD46F80A42B9909D8E7F4018D8E1u128.into())).await?;
//println!("{spond:?}");
}
//} else if true {
//
//#[derive(Debug, serde::Deserialize, serde::Serialize)]
//struct Spond(serde_json::Value);
//
//#[derive(Debug, serde::Deserialize, serde::Serialize)]
//struct Sponds(Vec<Spond>);
//
//impl restson::RestPath<()> for Sponds {
// fn get_path(_: ()) -> std::result::Result<String, restson::Error> {
// Ok(String::from("sponds"))
// }
//}
// let now = &DateTime::default();
// log::info!("{now:?} | {}", now.to_string());
// let query = [
// ("includeComments", "true"),
// //("includeHidden", "true"),
// ("addProfileInfo", "true"),
// ("hidden", "true"),
// ("scheduled", "true"),
// ("order", "asc"),
// ("max", "20"),
// ("heading", "Schwimmtraining Donnerstag"),
// ("seriesId", "CCBE049C31DA4FB691158E3FBC2DFBC8u128"),
// ("minStartTimestamp", &now.to_string()),
// ];
//
// for spond in client.get_with::<_, api::spond::Sponds>((), &query).await?.into_inner().0 {
// //match spond.0 {
// // serde_json::Value::Object(map) => {
// // println!("{:?}", map);
// // },
// // _ => {},
// //};
// println!("{}", serde_json::to_string_pretty(&spond).unwrap());
// }
//} else {
// let request = api::sponds()
// .add_profile_info(false)
// .comments(true)
// .hidden(false)
// .scheduled(true)
// ;
// for spond in request.call(&client).await? {
// println!("{spond:?}");
// }
}
Ok(())