brickset 0.1.1

BrickSet API bindings
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

use brickset::v3::{request::OrderBy, reqwest_api::ClientWrapper, response::LegoComDetails};
use dotenv;
use std::{env, fs::File, io::Write};

#[tokio::main]
async fn main() {
    if dotenv::from_filename(".env.examples").is_err() {
        println!("Did not find .env.examples! If BRICKSET_KEY and BRICKSET_USERNAME aren't set in your environment, the example will crash.");
    }

    // load stuff from the environment
    let api_key = env::var("BRICKSET_KEY")
        .expect("Missing environment variable BRICKSET_KEY");
    let username = env::var("BRICKSET_USERNAME")
        .expect("Missing environment variable BRICKSET_USERNAME");

    let client = reqwest::Client::default();
    let mut client = ClientWrapper::new(&api_key, &client);

    // log into BrickSet
    log_into_brickset(&mut client, &username).await;

    // retrieve the user's wanted sets
    let sets = client
        .get_wanted_sets(OrderBy::PiecesDESC.into(), Some(500), None, false)
        .await
        .expect("get_wanted_sets");

    // print results
    println!("User has {} sets in wantlist", sets.matches);

    let unknown = "Unknown".to_string();

    for set in sets.sets.iter() {
        println!("{}-{} {}", set.number, set.number_variant, set.name.as_ref().unwrap_or(&unknown));
        println!("  Theme: {} (Subtheme: {})", set.theme.as_ref().unwrap_or(&unknown), set.subtheme.as_ref().unwrap_or(&unknown));
        println!("  Pieces: {}", set.pieces.map_or_else(|| unknown.clone(), |p| p.to_string()));
        println!("  Availability: {}", set.availability.as_ref().unwrap_or(&unknown));
        println!("  Pricing on LEGO.com:");
        print_pricing("USD", &set.lego_com.united_states);
        print_pricing("CAD", &set.lego_com.canada);
        print_pricing("EUR", &set.lego_com.germany);
        print_pricing("GBP", &set.lego_com.united_kingdom);
    }
}

fn print_pricing(tag: &str, details: &LegoComDetails) {
    if let Some(price) = details.retail_price {
        print!("  - {price:.2} {tag}");
        if let Some(last_available) = details.date_last_available {
            print!(" Last available: {}", last_available.format("%Y-%m-%d"));
        }
        println!("");
    }
}

async fn log_into_brickset<'a>(client: &mut ClientWrapper<'a>, username: &str) {
    println!("Logging in...");

    // try to log in using cached token
    if dotenv::from_filename(".env.examples.generated").is_ok() {
        if let Some(user_hash) = env::var("BRICKSET_USER_HASH").ok() {
            match client.reuse_login(&user_hash).await {
                Ok(_) => println!("Logged in using cached token"),
                Err(err) => println!("Could not log in with cached token: {err}"),
            }
        }
    }

    if !client.is_logged_in() {
        // couldn't log in using cached token, so ask for a password
        println!("Username: {username}");
        let password = rpassword::prompt_password("Password: ").unwrap();
        let login = client.log_in(&username, &password).await.expect("log_in");

        println!("Successfully logged in");

        // successfully logged in, save the new token
        let fp = File::options()
            .create(true)
            .write(true)
            .truncate(true)
            .open(".env.examples.generated");

        if let Ok(mut fp) = fp {
            fp.write_fmt(format_args!("BRICKSET_USER_HASH={:?}", login.hash))
                .expect("write_fmt");
        }
    }
}