egs-api 0.14.0

Interface to the Epic Games 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

#[path = "common.rs"]
mod common;

use egs_api::EpicGames;

#[tokio::main]
async fn main() {
    env_logger::init();
    let mut egs = EpicGames::new();

    if !common::login_or_restore(&mut egs).await {
        eprintln!("Authentication failed. Run the 'auth' example first.");
        std::process::exit(1);
    }

    println!("=== Catalog Items ===\n");

    let namespace = "fn";
    match egs.catalog_items(namespace, 0, 10).await {
        Some(page) => {
            if let Some(paging) = &page.paging {
                println!("Total items in '{}': {}", namespace, paging.total);
            }
            for item in &page.elements {
                println!(
                    "  [{}] {} (type: {})",
                    item.id,
                    item.title.as_deref().unwrap_or("(untitled)"),
                    item.item_type.as_deref().unwrap_or("unknown"),
                );
            }
        }
        None => eprintln!("Failed to fetch catalog items for '{}'", namespace),
    }

    println!("\n=== Catalog Offers ===\n");

    match egs.catalog_offers(namespace, 0, 10).await {
        Some(page) => {
            if let Some(paging) = &page.paging {
                println!("Total offers in '{}': {}", namespace, paging.total);
            }
            for offer in &page.elements {
                println!(
                    "  [{}] {} (type: {}, items: {})",
                    offer.id,
                    offer.title.as_deref().unwrap_or("(untitled)"),
                    offer.offer_type.as_deref().unwrap_or("unknown"),
                    offer.items.len(),
                );
            }
        }
        None => eprintln!("Failed to fetch catalog offers for '{}'", namespace),
    }

    println!("\n=== Bulk Catalog Items ===\n");

    let assets = egs.list_assets(None, None).await;
    let items: Vec<(&str, &str)> = assets
        .iter()
        .take(3)
        .map(|a| (a.namespace.as_str(), a.catalog_item_id.as_str()))
        .collect();

    if items.is_empty() {
        println!("No assets found, skipping bulk catalog demo.");
        return;
    }

    println!("Looking up {} items across namespaces...", items.len());
    match egs.bulk_catalog_items(&items).await {
        Some(result) => {
            for (ns, items_map) in &result {
                for (item_id, info) in items_map {
                    println!(
                        "  {}/{}: {}",
                        ns,
                        item_id,
                        info.title.as_deref().unwrap_or("(untitled)")
                    );
                }
            }
        }
        None => eprintln!("Failed to fetch bulk catalog items"),
    }
}