gwelle 0.1.0

Lightweight Rust client for the Google Trends 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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExploreRequest {
    pub keywords: Vec<String>,
    pub geo: String,
    pub timeframe: String,
    pub category: u32,
    pub property: String,
}

impl Default for ExploreRequest {
    fn default() -> Self {
        Self {
            keywords: vec![],
            geo: "".to_string(),
            timeframe: "today 12-m".to_string(),
            category: 0,
            property: "".to_string(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExploreTokens {
    pub interest_over_time: Option<WidgetToken>,
    pub interest_by_region: Option<WidgetToken>,
    pub related_topics: Option<WidgetToken>,
    pub related_queries: Option<WidgetToken>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WidgetToken {
    pub token: String,
    pub request: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InterestOverTime {
    pub timeline_data: Vec<TimelinePoint>,
    pub averages: Vec<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TimelinePoint {
    pub time: String,
    pub formatted_time: String,
    pub values: Vec<u32>,
    pub is_partial: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InterestByRegion {
    pub geo_map_data: Vec<GeoPoint>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GeoPoint {
    #[serde(rename = "geoCode")]
    pub geo_code: String,
    #[serde(rename = "geoName")]
    pub geo_name: String,
    pub values: Vec<u32>,
    pub coordinates: Option<Coordinates>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Coordinates {
    pub lat: f64,
    pub lng: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum GeoResolution {
    Country,
    Region,
    City,
    DMA,
}

impl GeoResolution {
    pub fn as_str(&self) -> &'static str {
        match self {
            GeoResolution::Country => "COUNTRY",
            GeoResolution::Region => "REGION",
            GeoResolution::City => "CITY",
            GeoResolution::DMA => "DMA",
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RelatedQueries {
    pub top: Vec<RelatedItem>,
    pub rising: Vec<RelatedItem>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RelatedItem {
    pub query: String,
    pub value: String,
    pub link: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RealtimeTrend {
    pub title: Vec<String>,
    pub entity_names: Vec<String>,
    pub articles: Vec<TrendArticle>,
    pub image: Option<TrendImage>,
    pub share_url: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrendArticle {
    #[serde(rename = "articleTitle")]
    pub article_title: String,
    pub url: String,
    pub source: String,
    #[serde(rename = "timeAgo")]
    pub time_ago: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TrendImage {
    #[serde(rename = "newsUrl")]
    pub news_url: String,
    pub source: String,
    #[serde(rename = "imgUrl")]
    pub img_url: String,
}