google-analytics-api-ga4 0.2.0

Async Rust client for the Google Analytics 4 (GA4) Data API v1beta: runReport, realtime reports, pivot reports, and metadata
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

use google_analytics_api_ga4::types::{
    DateRange, Dimension, Filter, FilterExpression, FilterExpressionList, MatchType, Metric,
    StringFilter,
};
use google_analytics_api_ga4::{AnalyticsDataApi, RunRealtimeReportRequest, RunReportRequest};
use yup_oauth2::AccessToken;

async fn test_token() -> AccessToken {
    // 認証
    let secret = yup_oauth2::read_service_account_key("./test.json")
        .await
        .expect("test.json");
    let auth = yup_oauth2::ServiceAccountAuthenticator::builder(secret)
        .build()
        .await
        .unwrap();
    let scopes = &["https://www.googleapis.com/auth/analytics.readonly"];

    let token = auth.token(scopes).await;
    assert!(token.is_ok(), "{}", token.err().unwrap().to_string());
    token.unwrap()
}

#[tokio::test]
#[ignore = "requires test.json service account credentials"]
async fn test_run_realtime_report() {
    let token = test_token().await;
    let property_id = "252735638";

    let request = RunRealtimeReportRequest {
        dimensions: Dimension::from_string_vec(vec!["appVersion"]),
        metrics: Metric::from_string_vec(vec!["activeUsers"]),
        limit: Some("2".to_string()),
        ..RunRealtimeReportRequest::default()
    };

    let run_report =
        AnalyticsDataApi::run_realtime_report(token.as_str(), property_id, request).await;
    assert!(run_report.is_ok(), "{}", run_report.err().unwrap());
    let run_report = run_report.unwrap();
    let metric_headers = run_report.metric_headers.unwrap_or_default();
    let rows = run_report.rows.unwrap_or_default();
    for header in metric_headers {
        println!("{:?}", header);
    }
    for row in rows {
        println!("{:?}", row.metric_values);
    }
}

#[tokio::test]
#[ignore = "requires test.json service account credentials"]
async fn test_run_report() {
    let token = test_token().await;
    let property_id = "252735638";

    let dimension_filter = FilterExpression {
        and_group: Some(FilterExpressionList {
            expressions: Some(vec![
                FilterExpression {
                    filter: Some(Filter {
                        field_name: Some("fullPageUrl".to_string()),
                        string_filter: Some(StringFilter {
                            match_type: Some(MatchType::BeginsWith),
                            value: Some("uiuifree.com".to_string()),
                            ..StringFilter::default()
                        }),
                        ..Filter::default()
                    }),
                    ..FilterExpression::default()
                },
                FilterExpression {
                    filter: Some(Filter {
                        field_name: Some("eventName".to_string()),
                        string_filter: Some(StringFilter {
                            match_type: Some(MatchType::BeginsWith),
                            value: Some("session_start".to_string()),
                            ..StringFilter::default()
                        }),
                        ..Filter::default()
                    }),
                    ..FilterExpression::default()
                },
            ]),
        }),
        ..FilterExpression::default()
    };

    let request = RunReportRequest {
        property: format!("properties/{}", property_id),
        dimensions: Dimension::from_string_vec(vec!["fullPageUrl", "eventName"]),
        metrics: Metric::from_string_vec(vec![
            "sessions",
            "screenPageViews",
            "eventCount",
            "eventValue",
        ]),
        date_ranges: vec![DateRange::new("test", "2022-01-01", "2022-06-12")],
        dimension_filter: Some(dimension_filter),
        limit: Some("20".to_string()),
        ..RunReportRequest::default()
    };

    let run_report = AnalyticsDataApi::run_report(token.as_str(), property_id, request).await;
    assert!(run_report.is_ok(), "{}", run_report.err().unwrap());
    let run_report = run_report.unwrap();
    let metric_headers = run_report.metric_headers.unwrap_or_default();
    let rows = run_report.rows.unwrap_or_default();
    for header in metric_headers {
        println!("{:?}", header);
    }
    for row in rows {
        println!("{:?}", row.metric_values);
        println!("{:?}", row.dimension_values);
    }
}