funpay_client/client/
http.rs

1use crate::client::urls::UrlBuilder;
2use crate::client::FunpayGateway;
3use crate::config::FunPayConfig;
4use crate::error::FunPayError;
5use crate::models::OfferEditParams;
6use async_trait::async_trait;
7use reqwest::{Client, StatusCode, header, redirect::Policy};
8use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
9use reqwest_retry::{policies::ExponentialBackoff, RetryTransientMiddleware};
10use serde_json::Value;
11use std::time::{SystemTime, UNIX_EPOCH};
12
13pub struct ReqwestGateway {
14    pub client: ClientWithMiddleware,
15    pub urls: UrlBuilder,
16}
17
18impl ReqwestGateway {
19    pub fn new() -> Self {
20        Self::with_config(&FunPayConfig::default())
21    }
22
23    pub fn with_config(config: &FunPayConfig) -> Self {
24        let retry_policy = ExponentialBackoff::builder()
25            .base(config.retry_base_ms)
26            .build_with_max_retries(config.max_retries);
27
28        let client = ClientBuilder::new(
29            Client::builder()
30                .redirect(Policy::limited(config.redirect_limit))
31                .build()
32                .unwrap(),
33        )
34        .with(RetryTransientMiddleware::new_with_policy(retry_policy))
35        .build();
36
37        Self {
38            client,
39            urls: UrlBuilder::new(&config.base_url),
40        }
41    }
42
43    pub fn with_proxy(proxy_url: &str) -> Self {
44        Self::with_proxy_and_config(proxy_url, &FunPayConfig::default())
45    }
46
47    pub fn with_proxy_and_config(proxy_url: &str, config: &FunPayConfig) -> Self {
48        fn normalize_proxy_url(raw: &str) -> String {
49            if raw.contains('@') {
50                return raw.to_string();
51            }
52            if let Some((scheme, rest)) = raw.split_once("://") {
53                let parts: Vec<&str> = rest.split(':').collect();
54                if parts.len() == 4 {
55                    let host = parts[0];
56                    let port = parts[1];
57                    let user = parts[2];
58                    let pass = parts[3];
59                    return format!("{scheme}://{user}:{pass}@{host}:{port}");
60                }
61            }
62            raw.to_string()
63        }
64
65        let retry_policy = ExponentialBackoff::builder()
66            .base(config.retry_base_ms)
67            .build_with_max_retries(config.max_retries);
68
69        let normalized = normalize_proxy_url(proxy_url);
70        let client = ClientBuilder::new(
71            Client::builder()
72                .redirect(Policy::limited(config.redirect_limit))
73                .proxy(reqwest::Proxy::all(&normalized).expect("invalid proxy url"))
74                .build()
75                .expect("failed to build reqwest client with proxy"),
76        )
77        .with(RetryTransientMiddleware::new_with_policy(retry_policy))
78        .build();
79
80        Self {
81            client,
82            urls: UrlBuilder::new(&config.base_url),
83        }
84    }
85
86    fn add_common_headers(
87        &self,
88        builder: reqwest_middleware::RequestBuilder,
89        golden_key: &str,
90        user_agent: &str,
91        phpsessid: Option<&str>,
92    ) -> reqwest_middleware::RequestBuilder {
93        let cookie = if let Some(sess) = phpsessid {
94            format!("golden_key={golden_key}; cookie_prefs=1; PHPSESSID={sess}")
95        } else {
96            format!("golden_key={golden_key}; cookie_prefs=1")
97        };
98
99        builder
100            .header(header::COOKIE, cookie)
101            .header(header::USER_AGENT, user_agent)
102    }
103
104    async fn execute(
105        &self,
106        builder: reqwest_middleware::RequestBuilder,
107    ) -> Result<reqwest::Response, FunPayError> {
108        let resp = builder.send().await?;
109        if resp.status() == StatusCode::FORBIDDEN {
110            return Err(FunPayError::Unauthorized);
111        }
112        if !resp.status().is_success() {
113            let status = resp.status();
114            let url = resp.url().to_string();
115            let body = resp.text().await.unwrap_or_default();
116            return Err(FunPayError::RequestFailed { status, body, url });
117        }
118        Ok(resp)
119    }
120}
121
122impl Default for ReqwestGateway {
123    fn default() -> Self {
124        Self::new()
125    }
126}
127
128#[async_trait]
129impl FunpayGateway for ReqwestGateway {
130    async fn get_home(
131        &self,
132        golden_key: &str,
133        user_agent: &str,
134    ) -> Result<(String, Vec<String>), FunPayError> {
135        let url = self.urls.home();
136        let req = self.client.get(&url);
137        let req = self.add_common_headers(req, golden_key, user_agent, None);
138        let resp = self.execute(req).await?;
139
140        let set_cookies: Vec<String> = resp
141            .headers()
142            .get_all(header::SET_COOKIE)
143            .iter()
144            .filter_map(|v| v.to_str().ok().map(|s| s.to_string()))
145            .collect();
146        let body = resp.text().await?;
147        Ok((body, set_cookies))
148    }
149
150    async fn get_chat_page(
151        &self,
152        golden_key: &str,
153        user_agent: &str,
154        chat_id: &str,
155    ) -> Result<(String, Vec<String>), FunPayError> {
156        let chat_url = self.urls.chat_page(chat_id);
157        let req = self
158            .client
159            .get(&chat_url)
160            .header(header::ACCEPT, "*/*");
161        let req = self.add_common_headers(req, golden_key, user_agent, None);
162        let resp = self.execute(req).await?;
163
164        let set_cookies: Vec<String> = resp
165            .headers()
166            .get_all(header::SET_COOKIE)
167            .iter()
168            .filter_map(|v| v.to_str().ok().map(|s| s.to_string()))
169            .collect();
170        let body = resp.text().await.unwrap_or_default();
171        Ok((body, set_cookies))
172    }
173
174    async fn get_orders_trade(
175        &self,
176        golden_key: &str,
177        user_agent: &str,
178    ) -> Result<String, FunPayError> {
179        let url = self.urls.orders_trade();
180        let req = self.client.get(&url).header(header::ACCEPT, "*/*");
181        let req = self.add_common_headers(req, golden_key, user_agent, None);
182        let resp = self.execute(req).await?;
183        let body = resp.text().await?;
184        Ok(body)
185    }
186
187    async fn get_order_page(
188        &self,
189        golden_key: &str,
190        user_agent: &str,
191        order_id: &str,
192    ) -> Result<String, FunPayError> {
193        let url = self.urls.order_page(order_id);
194        let req = self.client.get(&url).header(header::ACCEPT, "*/*");
195        let req = self.add_common_headers(req, golden_key, user_agent, None);
196        let resp = self.execute(req).await?;
197        let body = resp.text().await?;
198        Ok(body)
199    }
200
201    async fn post_runner(
202        &self,
203        golden_key: &str,
204        user_agent: &str,
205        csrf: &str,
206        phpsessid: Option<&str>,
207        objects_json: &str,
208        request_json: Option<&str>,
209    ) -> Result<Value, FunPayError> {
210        let url = self.urls.runner();
211        let payload = match request_json {
212            Some(req) => format!(
213                "objects={}&request={}&csrf_token={}",
214                urlencoding::encode(objects_json),
215                urlencoding::encode(req),
216                urlencoding::encode(csrf)
217            ),
218            None => format!(
219                "objects={}&request=false&csrf_token={}",
220                urlencoding::encode(objects_json),
221                urlencoding::encode(csrf)
222            ),
223        };
224
225        let req = self
226            .client
227            .post(&url)
228            .header(
229                header::CONTENT_TYPE,
230                "application/x-www-form-urlencoded; charset=UTF-8",
231            )
232            .header("x-requested-with", "XMLHttpRequest")
233            .header(header::ACCEPT, "*/*")
234            .header(header::ORIGIN, self.urls.base_url())
235            .header(header::REFERER, format!("{}/chat/", self.urls.base_url()))
236            .body(payload);
237
238        let req = self.add_common_headers(req, golden_key, user_agent, phpsessid);
239        let resp = self.execute(req).await?;
240        let v: Value = resp.json().await?;
241        Ok(v)
242    }
243
244    async fn post_offer_save(
245        &self,
246        golden_key: &str,
247        user_agent: &str,
248        phpsessid: Option<&str>,
249        csrf: &str,
250        offer_id: i64,
251        node_id: i64,
252        params: &OfferEditParams,
253    ) -> Result<Value, FunPayError> {
254        let url = self.urls.offer_save();
255        let form_created_at = SystemTime::now()
256            .duration_since(UNIX_EPOCH)
257            .map(|d| d.as_secs())
258            .unwrap_or(0);
259
260        let field = |key: &str, val: Option<&str>| {
261            format!(
262                "{}={}",
263                urlencoding::encode(key),
264                urlencoding::encode(val.unwrap_or(""))
265            )
266        };
267
268        let mut form_parts = vec![
269            format!("csrf_token={}", urlencoding::encode(csrf)),
270            format!("form_created_at={form_created_at}"),
271            format!("offer_id={offer_id}"),
272            format!("node_id={node_id}"),
273            field("location", params.location.as_deref()),
274            format!(
275                "deleted={}",
276                if params.deleted.unwrap_or(false) {
277                    "1"
278                } else {
279                    ""
280                }
281            ),
282            field("fields[quantity]", params.quantity.as_deref()),
283            field("fields[quantity2]", params.quantity2.as_deref()),
284            field("fields[method]", params.method.as_deref()),
285            field("fields[type]", params.offer_type.as_deref()),
286            field("server_id", params.server_id.as_deref()),
287            field("fields[desc][ru]", params.desc_ru.as_deref()),
288            field("fields[desc][en]", params.desc_en.as_deref()),
289            field("fields[payment_msg][ru]", params.payment_msg_ru.as_deref()),
290            field("fields[payment_msg][en]", params.payment_msg_en.as_deref()),
291            field("fields[summary][ru]", params.summary_ru.as_deref()),
292            field("fields[summary][en]", params.summary_en.as_deref()),
293            field("fields[game]", params.game.as_deref()),
294            field("fields[images]", params.images.as_deref()),
295            field("price", params.price.as_deref()),
296        ];
297
298        if params.deactivate_after_sale.unwrap_or(false) {
299            form_parts.push(field("deactivate_after_sale[]", None));
300            form_parts.push(field("deactivate_after_sale[]", Some("on")));
301        } else {
302            form_parts.push(field("deactivate_after_sale", None));
303        }
304
305        if params.active.unwrap_or(true) {
306            form_parts.push(field("active", Some("on")));
307        } else {
308            form_parts.push(field("active", None));
309        }
310
311        let payload = form_parts.join("&");
312        let referer = self.urls.offer_edit(node_id, offer_id);
313
314        log::debug!(
315            target: "funpay_client",
316            "POST {} | offer_id={} node_id={} price={:?}\nPayload: {}",
317            url,
318            offer_id,
319            node_id,
320            params.price,
321            payload
322        );
323
324        let req = self
325            .client
326            .post(&url)
327            .header(
328                header::CONTENT_TYPE,
329                "application/x-www-form-urlencoded; charset=UTF-8",
330            )
331            .header("x-requested-with", "XMLHttpRequest")
332            .header(
333                header::ACCEPT,
334                "application/json, text/javascript, */*; q=0.01",
335            )
336            .header(header::ORIGIN, self.urls.base_url())
337            .header(header::REFERER, referer)
338            .body(payload);
339
340        let req = self.add_common_headers(req, golden_key, user_agent, phpsessid);
341        let resp = self.execute(req).await?;
342
343        let status = resp.status();
344        let body_text = resp.text().await.unwrap_or_default();
345        log::info!(
346            target: "funpay_client",
347            "Response from offerSave: status={} body={}",
348            status, // accessing status after check is fine since it's Copy, but I should've saved it or execute return logic...
349            // Wait, execute returns Response.
350            body_text
351        );
352        // execute already checks status.
353
354        let v: Value = serde_json::from_str(&body_text).unwrap_or(Value::Null);
355        Ok(v)
356    }
357
358    async fn get_offer_edit_page(
359        &self,
360        golden_key: &str,
361        user_agent: &str,
362        node_id: i64,
363        offer_id: i64,
364    ) -> Result<String, FunPayError> {
365        let url = self.urls.offer_edit(node_id, offer_id);
366        let req = self.client.get(&url).header(header::ACCEPT, "*/*");
367        let req = self.add_common_headers(req, golden_key, user_agent, None);
368        let resp = self.execute(req).await?;
369        let body = resp.text().await?;
370        Ok(body)
371    }
372
373    async fn get_lots_trade_page(
374        &self,
375        golden_key: &str,
376        user_agent: &str,
377        node_id: i64,
378    ) -> Result<String, FunPayError> {
379        let url = self.urls.lots_trade(node_id);
380        let req = self.client.get(&url).header(header::ACCEPT, "*/*");
381        let req = self.add_common_headers(req, golden_key, user_agent, None);
382        let resp = self.execute(req).await?;
383        let body = resp.text().await?;
384        Ok(body)
385    }
386
387    async fn get_lots_page(
388        &self,
389        golden_key: &str,
390        user_agent: &str,
391        node_id: i64,
392    ) -> Result<String, FunPayError> {
393        let url = self.urls.lots_page(node_id);
394        let req = self.client.get(&url).header(header::ACCEPT, "*/*");
395        let req = self.add_common_headers(req, golden_key, user_agent, None);
396        let resp = self.execute(req).await?;
397        let body = resp.text().await?;
398        Ok(body)
399    }
400}
funpay_client/client/http.rs

funpay_client/client/
http.rs
