lightcone 0.6.1

Rust SDK for the Lightcone Protocol — unified native + WASM client
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

//! Referral sub-client — beta status and code redemption.

use crate::client::LightconeClient;
use crate::domain::referral::wire::{RedeemRequest, RedeemResponse, ReferralStatusResponse};
use crate::domain::referral::{RedeemResult, ReferralCodeInfo, ReferralStatus};
use crate::error::SdkError;
use crate::http::RetryPolicy;

pub struct Referrals<'a> {
    pub(crate) client: &'a LightconeClient,
}

impl<'a> Referrals<'a> {
    pub async fn get_status(&self) -> Result<ReferralStatus, SdkError> {
        let url = format!("{}/api/referral/status", self.client.http.base_url());
        let resp: ReferralStatusResponse =
            self.client.http.get(&url, RetryPolicy::Idempotent).await?;

        Ok(referral_status_from_wire(resp))
    }

    /// Same as [`Self::get_status`], but uses the supplied `auth_token` for
    /// this call instead of the SDK's process-wide token store. For
    /// server-side cookie forwarding (SSR / server functions).
    pub async fn get_status_with_auth(&self, auth_token: &str) -> Result<ReferralStatus, SdkError> {
        let url = format!("{}/api/referral/status", self.client.http.base_url());
        let resp: ReferralStatusResponse = self
            .client
            .http
            .get_with_auth(&url, RetryPolicy::Idempotent, auth_token)
            .await?;
        Ok(referral_status_from_wire(resp))
    }

    pub async fn redeem(&self, code: &str) -> Result<RedeemResult, SdkError> {
        let url = format!("{}/api/referral/redeem", self.client.http.base_url());
        let body = RedeemRequest {
            code: code.to_string(),
        };
        let resp: RedeemResponse = self
            .client
            .http
            .post(&url, &body, RetryPolicy::None)
            .await?;

        Ok(RedeemResult {
            success: resp.success,
            is_beta: resp.is_beta,
        })
    }
}

fn referral_status_from_wire(resp: ReferralStatusResponse) -> ReferralStatus {
    ReferralStatus {
        is_beta: resp.is_beta,
        source: resp.source,
        referral_codes: resp
            .referral_codes
            .into_iter()
            .map(|c| ReferralCodeInfo {
                code: c.code,
                max_uses: c.max_uses,
                use_count: c.use_count,
            })
            .collect(),
    }
}