ig-client 0.11.3

This crate provides a client for the IG Markets 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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

// Integration tests for account endpoints

use crate::common;
use ig_client::prelude::*;
use tokio::runtime::Runtime;
use tracing::info;

#[test]
#[ignore]
fn test_get_accounts() {
    setup_logger();
    // Create client
    let client = common::create_test_client();

    // Create a runtime for the async operations
    let rt = Runtime::new().expect("Failed to create runtime");

    // Test get accounts
    rt.block_on(async {
        info!("Getting accounts");

        let result = client.get_accounts().await.expect("Failed to get accounts");

        // Verify the result contains the expected data
        assert!(
            !result.accounts.is_empty(),
            "Should return at least one account"
        );

        info!("Retrieved {} accounts", result.accounts.len());

        // Print the accounts
        for (i, account) in result.accounts.iter().enumerate() {
            info!(
                "{}. {} (ID: {})",
                i + 1,
                account.account_name,
                account.account_id
            );
            info!(
                "   Type: {}, Status: {}",
                account.account_type, account.status
            );
            info!("   Currency: {}", account.currency);
            info!(
                "   Can trade: {}",
                if account.preferred { "Yes" } else { "No" }
            );
        }
    });
}

#[test]
#[ignore]
fn test_get_account_activity() {
    setup_logger();
    // Create client
    let client = common::create_test_client();

    // Create a runtime for the async operations
    let rt = Runtime::new().expect("Failed to create runtime");

    // Test get account activity
    rt.block_on(async {
        // Use a date range for the last 7 days
        use chrono::{Duration, Utc};

        let to = Utc::now();
        let from = to - Duration::days(7);

        let from_str = from.format("%Y-%m-%d").to_string();
        let to_str = to.format("%Y-%m-%d").to_string();

        info!("Getting account activity from {} to {}", from_str, to_str);

        let result = client
            .get_activity(&from_str, &to_str)
            .await
            .expect("Failed to get account activity");

        // Print the activities
        info!("Retrieved {} account activities", result.activities.len());

        if result.activities.is_empty() {
            info!("No activities found in the specified date range");
        } else {
            for (i, activity) in result.activities.iter().enumerate() {
                info!(
                    "{}.  {:?} on {}",
                    i + 1,
                    activity.activity_type,
                    activity.date
                );
                info!("   Details: {:?}", activity.details);
                info!("   Channel: {:?}", activity.channel);
                info!("   Status: {:?}", activity.status);
            }
        }
    });
}

#[test]
#[ignore]
fn test_get_transaction_history() {
    setup_logger();
    // Create client
    let client = common::create_test_client();

    // Create a runtime for the async operations
    let rt = Runtime::new().expect("Failed to create runtime");

    // Test get transaction history
    rt.block_on(async {
        // Use a date range for the last 30 days
        use chrono::{Duration, Utc};

        let to = Utc::now();
        let from = to - Duration::days(30);

        let from_str = from.format("%Y-%m-%d").to_string();
        let to_str = to.format("%Y-%m-%d").to_string();

        info!(
            "Getting transaction history from {} to {}",
            from_str, to_str
        );

        let result = client
            .get_transactions(&from_str, &to_str)
            .await
            .expect("Failed to get transaction history");

        // Print the transactions
        info!("Retrieved {} transactions", result.transactions.len());

        if result.transactions.is_empty() {
            info!("No transactions found in the specified date range");
        } else {
            for (i, transaction) in result.transactions.iter().enumerate() {
                info!(
                    "{}. {} on {}",
                    i + 1,
                    transaction.transaction_type,
                    transaction.date
                );
                info!("   Instrument: {}", transaction.instrument_name);
                info!("   Reference: {}", transaction.reference);
                info!(
                    "   Amount: {} ({})",
                    transaction.profit_and_loss, transaction.currency
                );
            }
        }
    });
}