Struct Session 

pub struct Session { /* private fields */ }

Stateful comdirect API session with automatic token refresh.

The session encapsulates auth orchestration, transient-error retries, background refresh supervision, and endpoint access.

Example

use comdirect_rest_api::{Session, TanAction};
use std::io::{self, Write};

let session = Session::new("client-id", "client-secret", "username", "pin")?;

session
    .login(|challenge| async move {
        println!("challenge {}", challenge.challenge_id);
        println!("Approve the Push-TAN in your Comdirect app first.");
        print!("Press Enter after approval... ");
        let _ = io::stdout().flush();
        let mut line = String::new();
        let _ = io::stdin().read_line(&mut line);
        TanAction::ConfirmPushTan
    })
    .await?;

let balances = session.accounts().get_balances().await?;
println!("{} accounts", balances.values.len());

Implementations

impl Session

pub fn new( client_id: impl Into<String>, client_secret: impl Into<String>, username: impl Into<String>, password: impl Into<String>, ) -> Result<Self>

Creates a session using default runtime settings.

pub fn from_config(config: SessionConfig) -> Result<Self>

Creates a session from explicit SessionConfig.

pub fn accounts(&self) -> AccountsApi

Returns a copyable endpoint client for account operations.

pub fn brokerage(&self) -> BrokerageApi

Returns a copyable endpoint client for brokerage operations.

pub async fn set_state_change_callback<F>(&self, callback: F)

where F: Fn(SessionStateType, SessionStateType) + Send + Sync + 'static,

Registers a callback invoked on session state transitions.

pub async fn set_refresh_token_callback<F>(&self, callback: F)

where F: Fn(String) + Send + Sync + 'static,

Registers a callback invoked whenever a new refresh token is issued.

pub async fn state(&self) -> SessionStateType

Reads the current authorization state.

pub async fn try_restore(&self, refresh_token: &str) -> Result<()>

Performs non-interactive login using a persisted refresh token.

This is the preferred startup path for long-running services because it avoids interactive TAN prompts during cold start.

pub async fn login<F, Fut>(&self, callback: F) -> Result<()>

where F: Fn(LoginChallenge) -> Fut + Send + Sync, Fut: Future<Output = TanAction> + Send,

Performs interactive login and asks the callback how to answer TAN challenges.

The callback is awaited before TAN completion is submitted. For ConfirmPushTan, return only after the user has actually confirmed the challenge externally (for example via a frontend “I’ve allowed it” action).

Use this for initial bootstrap of refresh tokens. Persist the refresh token from set_refresh_token_callback and switch to Self::try_restore for subsequent restarts.

pub async fn shutdown(&self)

Stops background refresh tasks and marks the session unauthorized.

Call this before process shutdown to ensure refresh workers are cancelled deterministically.

Trait Implementations

impl Clone for Session

fn clone(&self) -> Session

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.