idkollen-client 0.1.0

API client for the IDkollen REST API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::client::{IdkollenError, PollOptions, WaitError};
use crate::models::{VippsAuthRequest, VippsBackchannelAuthRequest, VippsStatus};
use std::time::Instant;

#[cfg(feature = "async")]
use crate::client::IdkollenClient;

#[cfg(feature = "async")]
/// Vipps operations.
pub struct VippsEndpoint<'a>(pub(crate) &'a IdkollenClient);

#[cfg(feature = "async")]
impl VippsEndpoint<'_> {
    /// Start a Vipps authentication session.
    pub async fn auth(&self, req: VippsAuthRequest) -> Result<VippsStatus, IdkollenError> {
        self.0.post("/v3/vipps/auth", &req).await
    }

    /// Start a Vipps backchannel authentication session.
    pub async fn backchannel_auth(
        &self,
        req: VippsBackchannelAuthRequest,
    ) -> Result<VippsStatus, IdkollenError> {
        self.0.post("/v3/vipps/backchannel/auth", &req).await
    }

    /// Poll the current status of a Vipps authentication session.
    pub async fn auth_status(&self, id: &str) -> Result<VippsStatus, IdkollenError> {
        self.0.get(&format!("/v3/vipps/auth/{}", id)).await
    }

    /// Cancel a Vipps authentication session.
    pub async fn cancel_auth(&self, id: &str) -> Result<(), IdkollenError> {
        self.0.delete(&format!("/v3/vipps/auth/{}", id)).await
    }

    /// Poll until the authentication session reaches a terminal state or the timeout elapses.
    pub async fn wait_for_auth(
        &self,
        id: &str,
        opts: PollOptions,
    ) -> Result<VippsStatus, WaitError> {
        let deadline = Instant::now() + opts.timeout;

        loop {
            let status = self.auth_status(id).await?;

            match status {
                VippsStatus::Pending(_) => {
                    if Instant::now() >= deadline {
                        return Err(WaitError::Timeout);
                    }

                    tokio::time::sleep(opts.interval).await;
                },
                terminal => return Ok(terminal),
            }
        }
    }
}

#[cfg(feature = "blocking")]
use crate::client::IdkollenBlockingClient;

#[cfg(feature = "blocking")]
/// Vipps operations (blocking).
pub struct VippsBlockingEndpoint<'a>(pub(crate) &'a IdkollenBlockingClient);

#[cfg(feature = "blocking")]
impl VippsBlockingEndpoint<'_> {
    /// Start a Vipps authentication session.
    pub fn auth(&self, req: VippsAuthRequest) -> Result<VippsStatus, IdkollenError> {
        self.0.post("/v3/vipps/auth", &req)
    }

    /// Start a Vipps backchannel authentication session.
    pub fn backchannel_auth(
        &self,
        req: VippsBackchannelAuthRequest,
    ) -> Result<VippsStatus, IdkollenError> {
        self.0.post("/v3/vipps/backchannel/auth", &req)
    }

    /// Poll the current status of a Vipps authentication session.
    pub fn auth_status(&self, id: &str) -> Result<VippsStatus, IdkollenError> {
        self.0.get(&format!("/v3/vipps/auth/{}", id))
    }

    /// Cancel a Vipps authentication session.
    pub fn cancel_auth(&self, id: &str) -> Result<(), IdkollenError> {
        self.0.delete(&format!("/v3/vipps/auth/{}", id))
    }

    /// Poll until the authentication session reaches a terminal state or the timeout elapses.
    pub fn wait_for_auth(&self, id: &str, opts: PollOptions) -> Result<VippsStatus, WaitError> {
        let deadline = Instant::now() + opts.timeout;

        loop {
            let status = self.auth_status(id)?;

            match status {
                VippsStatus::Pending(_) => {
                    if Instant::now() >= deadline {
                        return Err(WaitError::Timeout);
                    }

                    std::thread::sleep(opts.interval);
                },
                terminal => return Ok(terminal),
            }
        }
    }
}