rtrend 0.1.7

Unofficial API for interacting with Google Trend
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
156
157
158
159
160
161
162
163
164
165
166
167
168

use std::collections::HashMap;

use crate::{
    utils, Client, Keywords, RegionInterest, RelatedQueries, RelatedTopics, SearchInterest,
};
use reqwest::{blocking::RequestBuilder, Url};
use serde_json::Value;

pub trait Query {
    // Build queries for all type of search
    fn build_request(&self) -> Vec<RequestBuilder>;

    // Send queries for request build previously
    fn send_request(&self) -> Vec<Value> {
        const BAD_CHARACTER: usize = 5;
        let mut responses: Vec<Value> = Vec::new();

        for request in self.build_request() {
            let resp = request.send();
            let resp = match resp {
                Ok(resp) => resp,
                Err(error) => panic!("Can't get client response: {:?}", error),
            };
            let body = resp.text().unwrap();
            let clean_response = utils::sanitize_response(&body, BAD_CHARACTER);
            responses.push(serde_json::from_str(clean_response).unwrap());
        }
        responses
    }
}

impl Query for SearchInterest {
    fn build_request(&self) -> Vec<RequestBuilder> {
        const MULTILINE_ENDPOINT: &str =
            "https://trends.google.com/trends/api/widgetdata/multiline";
        let url = Url::parse(MULTILINE_ENDPOINT).unwrap();

        let request = self.client.response["widgets"][0]["request"].to_string();
        let token = self.client.response["widgets"][0]["token"]
            .to_string()
            .replace('\"', "");

        vec![build_query(&self.client, url, request, token)]
    }
}

impl Query for RegionInterest {
    fn build_request(&self) -> Vec<RequestBuilder> {
        const COMPAREDGEO_ENDPOINT: &str =
            "https://trends.google.com/trends/api/widgetdata/comparedgeo";
        let url = Url::parse(COMPAREDGEO_ENDPOINT).unwrap();
        let keywords_nb = self.client.keywords.keywords.len();
        let mut requests: Vec<RequestBuilder> = Vec::new();

        if keywords_nb == 1 {
            let request = self.client.response["widgets"][1]["request"].clone();
            let mod_region_request = mod_region_request(request, self.resolution).to_string();

            let token = self.client.response["widgets"][1]["token"]
                .to_string()
                .replace('\"', "");

            vec![build_query(&self.client, url, mod_region_request, token)]
        } else {
            for i in 1..=keywords_nb {
                let request = self.client.response["widgets"][i * 3]["request"].clone();
                let mod_region_request = mod_region_request(request, self.resolution).to_string();

                let token = self.client.response["widgets"][i * 3]["token"]
                    .to_string()
                    .replace('\"', "");
                requests.push(build_query(
                    &self.client,
                    url.clone(),
                    mod_region_request,
                    token,
                ));
            }

            requests
        }
    }
}

impl Query for RelatedTopics {
    fn build_request(&self) -> Vec<RequestBuilder> {
        const RELATED_SEARCH_ENDPOINT: &str =
            "https://trends.google.com/trends/api/widgetdata/relatedsearches";
        let url = Url::parse(RELATED_SEARCH_ENDPOINT).unwrap();
        let keywords = self.client.keywords.keywords.clone();
        let mut requests: Vec<RequestBuilder> = Vec::new();

        if keywords.len() == 1 {
            let request = self.client.response["widgets"][2]["request"].to_string();
            let token = self.client.response["widgets"][2]["token"]
                .to_string()
                .replace('\"', "");
            vec![build_query(&self.client, url, request, token)]
        } else {
            for keyword in &keywords {
                let individual_keyword = Keywords::new(vec![keyword]);

                let new_client = self
                    .client
                    .clone()
                    .with_keywords(individual_keyword)
                    .build();
                let request = new_client.response["widgets"][2]["request"].to_string();
                let token = new_client.response["widgets"][2]["token"]
                    .to_string()
                    .replace('\"', "");
                requests.push(build_query(&new_client, url.clone(), request, token));
            }

            requests
        }
    }
}

impl Query for RelatedQueries {
    fn build_request(&self) -> Vec<RequestBuilder> {
        const RELATED_QUERY_ENDPOINT: &str =
            "https://trends.google.com/trends/api/widgetdata/relatedsearches";
        let url = Url::parse(RELATED_QUERY_ENDPOINT).unwrap();

        let mut requests: Vec<RequestBuilder> = Vec::new();
        let keywords_nb = self.client.keywords.keywords.len();

        if keywords_nb == 1 {
            let request = self.client.response["widgets"][3]["request"].to_string();
            let token = self.client.response["widgets"][3]["token"]
                .to_string()
                .replace('\"', "");
            vec![build_query(&self.client, url, request, token)]
        } else {
            for i in 1..=keywords_nb {
                let request = self.client.response["widgets"][i * 3 + 1]["request"].to_string();
                let token = self.client.response["widgets"][i * 3 + 1]["token"]
                    .to_string()
                    .replace('\"', "");
                requests.push(build_query(&self.client, url.clone(), request, token));
            }
            requests
        }
    }
}

fn build_query(client: &Client, url: Url, request: String, token: String) -> RequestBuilder {
    client.client.get(url).query(&[
        ("hl", client.lang.to_string().as_str()),
        ("tz", "-120"),
        ("req", request.as_str()),
        ("token", token.as_str()),
        ("tz", "-120"),
    ])
}

fn mod_region_request(request: Value, resolution: &str) -> Value {
    let mut config: HashMap<String, Value> =
        serde_json::from_value(request).expect("unable to parse JSON request");
    if let Some(mut res) = config["resolution"].as_str() {
        res = resolution;
        config.insert("resolution".to_string(), Value::from(res));
    } else {
        panic!("Unknown resolution");
    }
    serde_json::to_value(config).unwrap()
}